C++常用函数

cstring类型

比较和计算

strcmp(a,b);

比较返回两个char数组的差异度（-2表示有一个char不同）

strlen(a);

计算string或char数组的长度

size();

lenth();

函数	功能 是为1 否为0
isalpha	判断是否为字母
islower/isupper	小/大写字母
isdigit	数字
isalnum	字母或数字
tolower/toupper	转换为小/大写字母

初始化

memset(s, c, n);

将以开辟内存s的前n个直接初始化为c

n可以用sizeof(s)

复制

memcpy(b, a, n);

以a开头，长度为n的内存，拷贝到b中

strncpy(b,a,n);

以a开头，长度为n的内存，拷贝到b中，并返回b

strcpy(b,a);

从a开始复制给b，遇到NULL ‘/0’结束

strcat(b,a);

把a连接到b后

输入

getline(cin,a,n);

将流中的字符存在a中，

遇到n结束，没有默认为‘/n’

cctype

tolower(); toupper();

改变字母大小写

isalpha(); isdigit(); isprint();

判断是否是字母，数字，可打印字符（非控制字符）

algorithm

min(); max()

返回两个元素中最小（最大）的一个

upper_bound(first, last, n);

查找区间中第一个大于n的位置，返回的是地址

lower_bound(first, last, n);

查找区间中第一个大于等于n的位置，返回的是地址

next_permutation(first, last); prev_permutation();

将数组中的元素全排列

需要将数组进行升序排列，否则只能找出该序列之后的全排列数。

char a[4]={'a','b','c','d'};
    do{
        for(int i=0;i<4;++i)
            cout<<a[i]<<" ";
        cout<<endl;
    }while(next_permutation(a,a+4));

sort(first, last, greater<>());

int a[5]={5,2,4,3,1},b[3]="cba";
sort(a,a+5);//正序排列
sort(a,a+5,greater<>());//逆序排列数字
sort(b,b+3,greater<char>());//逆序排列char

fill(first, last, a);

可将数组的值初始化成a

vector

一个动态申请空间的数组

定义 vector < typename > name;

typename可以是任何基本类型 结构体,STL容器vector,set,queue等。

vector<int> stu;
vector<double> stu;
vector<char> stu;
vector<node> stu;//node是结构体类型
vector<vector<int>> name;
vector<typename> a[arraySize];//申请一个二维数组

初始化

//初始化了10个默认值为0的元素
vector<int> abc(10);
//初始化了10个值为1的元素
vector<int> cde(10，1); 

int a[5] = {1,2,3,4,5};
//通过数组a的地址初始化，注意地址是从0到5（左闭右开区间）
vector<int> b(a, a+5);

vector<int> a(5,1);
//通过a初始化
vector<int> b(a);

//insert初始化方式将同类型的迭代器对应的始末区间（左闭右开区间）内的值插入到vector中
vector<int> a(6,6);
vecot<int> b;
//将a[0]~a[2]插入到b中，b.size()由0变为3
b.insert(b.begin(), a.begin(), a.begin() + 3);
//在b开始位置处插入6个6
b.insert(b.begin(), 6, 6);

vector<int> a(5,1);
int a1[5] = {2,2,2,2,2};
vector<int> b(10);

 /*将a中元素全部拷贝到b开始的位置中,注意拷贝的区间为a.begin() ~ a.end()的左闭右开的区间*/
copy(a.begin(), a.end(), b.begin());

//拷贝区间也可以是数组地址构成的区间
copy(a1, a1+5, b.begin() + 5);

访问

下标访问

从0开始

迭代器

vector::iterator it;//it是一个迭代器变量

常用函数

push_back(a)

在vector最后面添加一个元素a

pop_back(x)

删除vector的尾元素x

size()

clear()

清空vector所有的元素

insert();

insert(it,x);向vector的任意迭代器it初传入一个元素x

a.insert(a.begin()+1, 5);在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
a.insert(a.begin()+1, 3,5);在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5
a.insert(a.begin()+1,b+3, b+6);b为数组，在a的第1个元素（从第0个算起）的位置插入b的第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8，插入元素后为1,4,5,9,2,3,4,5,9,8

erase()

erase(x); 删除单个元素

erase(a,b); 删除左闭右开区间内[a,b)的元素

copy(a.begin(),a.end(),b.begin()+1);

把a中的从a.begin()（包括它）到a.end()（不包括它）的元素复制到b中，从b.begin()+1的位置（包括它）开始复制，覆盖掉原有元素

find(a.begin(),a.end(),10);

在a中的从a.begin()（包括它）到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置

set

一个内部自动升序而且不重复元素的容器

定义

操作	效果
set c	产生一个空的set/multiset，不含任何元素
set c(op)	以op为排序准则，产生一个空的set/multiset

访问

只能通过迭代器

set::iterator it;//typename对应定义set时的类型，auto自动推断定义类型

常用函数

insert(x)

将x插入set容器中，并且自动递增排序和去重

size()

clear()

end()

返回最后一个的迭代器

find(x)

查找值为x的元素，返回它的迭代器

erase()

erase(x); 删除单个元素

erase(a,b); 删除左闭右开区间内[a,b)的元素

multiset

有序可重复的容器

通过重载确定排序规则

struct rec{
    int x,y;
};
struct cmp{
    bool operator()(const rec&a,const rec&b){
        return a.x<b.x||a.x==b.x&&a.y<b.y;
    }
};
multiset<rec,cmp>h;

map

建立key（第一个值）和value（第二个值） 的对应，以key为标准有序

定义

map<int , int> maps;

访问

maps[key] = value; //给key赋值，key有对应的value就覆盖

It->first = 1;

常用函数

insert()

maps.insert(pair<type,type>(1,1)); //maps[1] = 1;

find()

map<type,type>::iterator it = maps.find(x); //auto代替map<type,type>::iterator 自动推断值的类型

长度

maps.empty(); //空返回1

maps.size();

maps.count(x); //返回指定元素出现的次数

逆向迭代器

maps.rbegin(); //返回指向maps尾部的逆向迭代器

maps.rend(); //返回指向maps头部的逆向迭代器

bound

maps.lower_bound(); //返回键值>=给定元素的第一个迭代器

maps.upper_bound(); //返回键值>给定元素的第一个迭代器

遍历

for(map<type,type>::iterator it = maps.begin(); it != maps.end(); it++)

erase()

maps.erase(iterator)

maps.erase(type)

哈希hashtable

unordered_set 不存储重复元素

unordered_map 实现key和value的映射

对比set和unordered_set

map和unordered_set也相同

对比	set	unordered_set
有序	有序	无序
实现	BST或RBT	Hash Table
插入、删除	log n	平均O(1)，最坏O(n)

unordered_map的成员

成员方法	功能
begin()	返回指向容器中第一个键值对的正向迭代器。
end()	返回指向容器中最后一个键值对之后位置的正向迭代器。
cbegin()	和 begin() 功能相同，只不过在其基础上增加了 const 属性，即该方法返回的迭代器不能用于修改容器内存储的键值对。
cend()	和 end() 功能相同，只不过在其基础上，增加了 const 属性，即该方法返回的迭代器不能用于修改容器内存储的键值对。
empty()	若容器为空，则返回 true；否则 false。
size()	返回当前容器中存有键值对的个数。
max_size()	返回容器所能容纳键值对的最大个数，不同的操作系统，其返回值亦不相同。
operator[key]	该模板类中重载了 [] 运算符，其功能是可以向访问数组中元素那样，只要给定某个键值对的键 key，就可以获取该键对应的值。注意，如果当前容器中没有以 key 为键的键值对，则其会使用该键向当前容器中插入一个新键值对。
at(key)	返回容器中存储的键 key 对应的值，如果 key 不存在，则会抛出 out_of_range 异常。
find(key)	查找以 key 为键的键值对，如果找到，则返回一个指向该键值对的正向迭代器；反之，则返回一个指向容器中最后一个键值对之后位置的迭代器（如果 end() 方法返回的迭代器）。
count(key)	在容器中查找以 key 键的键值对的个数。
equal_range(key)	返回一个 pair 对象，其包含 2 个迭代器，用于表明当前容器中键为 key 的键值对所在的范围。
emplace()	向容器中添加新键值对，效率比 insert() 方法高。
emplace_hint()	向容器中添加新键值对，效率比 insert() 方法高。
insert()	向容器中添加新键值对。
erase()	删除指定键值对。
clear()	清空容器，即删除容器中存储的所有键值对。
swap()	交换 2 个 unordered_map 容器存储的键值对，前提是必须保证这 2 个容器的类型完全相等。
bucket_count()	返回当前容器底层存储键值对时，使用桶（一个线性链表代表一个桶）的数量。
max_bucket_count()	返回当前系统中，unordered_map 容器底层最多可以使用多少桶。
bucket_size(n)	返回第 n 个桶中存储键值对的数量。
bucket(key)	返回以 key 为键的键值对所在桶的编号。
load_factor()	返回 unordered_map 容器中当前的负载因子。负载因子，指的是的当前容器中存储键值对的数量（size()）和使用桶数（bucket_count()）的比值，即 load_factor() = size() / bucket_count()。
max_load_factor()	返回或者设置当前 unordered_map 容器的负载因子。
rehash(n)	将当前容器底层使用桶的数量设置为 n。
reserve()	将存储桶的数量（也就是 bucket_count() 方法的返回值）设置为至少容纳count个元（不超过最大负载因子）所需的数量，并重新整理容器。
hash_function()	返回当前容器使用的哈希函数对象。