| ContType c | 产生一个未含任何元素的空容器 |
| ContType c1(C2) | 产生一个同型容器 |
| ConType c(beg,end) | 复制[beg;end]区间内的元素，作为容器初值 |
| c.~ConType() | 删除所有元素，释放内存 |
| c.size() | 返回容器中的元素数量 |
| c.empty() | 判断容器是否为空（相当于size()==0，但可能更快） |
| c.max_size() | 返回元素的最大可能数量 |
| c1==c2 | 判断是否c1等于c2 |
| c1!=c2 | 判断是否c1不等于c2 |
| c1<c2 | 判断是否c1小于c2 |
| c1>c2 | 判断是否c1大于c2 |
| c1<=c2 | 判断是否c1小于等于c2 |
| c1>=c2 | 判断是否c1大于等于c2 |
| c1=c2 | 将c2的所有元素赋值给c1 |
| c1.swap(c2) | 交换c1和c2的数据 |
| swap(c1,c2) | 同上，是个全局函数 |
| c.begin() | 返回一个迭代器，指向第一个元素 |
| c.end() | 返回一个迭代器，指向最后一个元素的下一位置 |
| c.rbegin() | 返回一个逆向迭代器，指向逆向遍历时的第一元素 |
| c.rend() | 返回一个逆向迭代器，指向逆向遍历时的最后元素的下一位置 |
| c.insert(pos,elem) | 将elem的一份副本插于pos处。返回值和pos的意义并不相同 |
| c.erase(beg,end) | 移除[beg;end]区间内的所有元素。某些容器会返回未被移除的第一个接续元素 |
| c.clear() | 移除所有元素，令容器为空 |
| c.get_allocator() | 返回容器的内存模型（memory model） |
|
Vectors 的构造函数和析构函数
| |
| 操作 | 效果 |
| – | – |
| vector<Elem> c | 产生一个空vector，其中没有任何元素 |
| vector<Elem> c1(c2) | 产生另一个同型vector的副本（所有元素都被拷贝） |
| vector<Elem> c(n) | 利用元素的defualt构造函数生成一个大小为n的vector |
| vector<Elem> c(n,elem) | 产生一个大小为n的vector，每个元素值都是elem |
| vector<Elem> c(beg,end) | 产生一个vector，以区间[beg;end]作为元素初值 |
| c.~vector<Elem>() | 销毁所有元素，并释放内存 |
|
Vectors的非变动性操作
| |
| 操作 | 效果 |
| – | – |
| c.size() | 返回当前的元素数量 |
| c.empty() | 判断大小是否为零。等同于size()==0，但可能更快 |
| c.max_size() | 返回可容纳的元素最大数量 |
| c.capacity() | 返回重新分配空间前所容纳的元素最大数量 |
| c.reserve() | 如果容量不足，扩大 |
| c1==c2 | 判断c1是否等于c2 |
| c1!=c2 | 判断c2是否不等于c1 |
| c1<c2 | 判断c1是否小于c2 |
| c1>c2 | 判断c1是否大于c2 |
| c1<=c2 | 判断c1是否小于等于c2 |
| c1>=c2 | 判断c1是否大于等于c2 |
|
Vectors的赋值操作
| |
| 操作 | 效果 |
| – | – |
| c1=c2 | 将c2的全部元素赋值给c1 |
| c.assign(n,elem) | 复制n个elem，赋值给c |
| c.assign(beg,end) | 将区间[beg;end]内的元素赋值给c |
| c1.swap(c2) | 将c1和c2元素互换 |
| swap(c1,c2) | 同上，此为全局函数 |
|
直接用来存取vectors元素的各项操作
| |
| 操作 | 效果 |
| – | – |
| c.at(idx) | 返回索引idx所标示的元素。如果idx越界，抛出out_of_range |
| c[idx] | 返回索引idx所标示的元素。不进行范围检查 |
| c.front() | 返回第一个元素。不检查第一个元素是否存在 |
| c.back() | 返回最后一个元素。不检查最后一个元素是否存在 |
|
Vectors的迭代器相关函数
| |
| 操作 | 效果 |
| – | – |
| c.begin() | 返回一个随机存取迭代器，指向第一元素 |
| c.end() | 返回一个随机存取迭代器，指向最后一个元素的下一位置 |
| c.rbegin() | 返回一个逆向迭代器，指向逆向迭代的第一个元素 |
| c.rend() | 返回一个逆向迭代器，指向逆向迭代的最后一个元素的下一位置 |
|
vector的安插、移除相关操作
| |
| 操作 | 效果 |
| – | – |
| c.insert(pos,elem) | 在pos位置上插入一个elem副本，并返回新元素位置 |
| c.insert(pos,n,elem) | 在pos位置上插入n个elem副本。无回传值 |
| c.insert(pos,beg,end) | 在pos位置上插入区间[beg;end]内的所有元素的副本。无回传值 |
| c.push_back(elem) | 在尾部添加一个elem副本 |
| c.pop_back() | 移除最后一个元素（但不回传） |
| c.erase(pos) | 移除pos位置上的元素，返回下一元素的位置 |
| c.erase(beg,end) | 移除[beg;end]区间内的所有元素，返回下一个元素的位置 |
| c.resize(num) | 将元素数量改为num（如果size()变大了，多出来的新元素都需以default构造函数完成） |
| c.resize(num,elem) | 将元素数量改为num(如果size()变大了，多出来的新元素都是elem的副本） |
| c.clear() | 移除所有元素，将容器清空 |
|
vector的特殊操作
| |
| 操作 | 效果 |
| – | – |
| c.flip() | 将所有bool元素值取反，亦即求补码 |
| m[idx].flip() | 将索引idx的bit元素取反值 |
| m[mid]=val | 令索引idx的bit元素值为val（指定单一bit） |
| m[idx1]=m[idx2] | 令索引dix1的bit元素值为索引idx2的bit元素值 |
|
deques的构造函数和析构函数
| |
| 操作 | 效果 |
| – | – |
| deque<Elem> c | 产生一个空的deque |
| deque<Elem> c1(c2) | 针对某个deque产生同型副本（所有元素都被拷贝） |
| deque<Elem> c(n) | 产生一个deque，含有n个元素，这些元素均以default构造函数产生出来 |
| deque<Elem> c(n,elem) | 产生一个deque，含有n个元素，这些元素均是elem的副本 |
| deque<Elem> c(beg,end) | 产生一个deque，以区间[beg;end]内的元素为初值 |
| c.~deque<Elem>() | 销毁所有元素，释放内存 |
|
deque的非变动性操作（nonmodifying operations）
| |
| 操作 | 效果 |
| – | – |
| c.size() | 返回容器的实际元素个数 |
| c.empty() | 判断容器大小是否为零 |
| c.max_size() | 返回可容纳的最大元素数量 |
| c1==c2 | 判断是否c1等于c2 |
| c1!=c2 | 判断是否c1不等于c2 |
| c1<c2 | 判断是否c1小于c2 |
| c1>c2 | 判断是否c1大于c2 |
| c1<=c2 | 判断是否c1小于等于c2 |
| c1>=c2 | 判断是否c1大于等于c1 |
| c.at(idx) | 返回索引idx所标示的元素。如果idx越界，抛出out_of_range |
| c[idx] | 返回索引idx所标示的元素，不进行范围检查 |
| c.front() | 返回第一个元素，不检查元素是否存在 |
| c.back() | 返回最后一个元素，不检查元素是否存在 |
| c.begin() | 返回一个随机迭代器，指向第一个元素 |
| c.end() | 返回一个随机迭代器，指向最后一个元素的下一位置 |
| c.rbegin() | 返回一个逆向迭代器，指向逆向迭代是的第一个元素 |
| c.rend() | 返回一个逆向迭代器，指向逆向迭代时的最后元素的下一位置 |
|
deque的变动性操纵（modifying operation）
| |
| 操作 | 效果 |
| – | – |
| c1=c2 | 将c2的所有元素赋值给c1 |
| c.assign(n,elem) | 将n个副本赋值给c |
| c.assign(beg,end) | 将区间[beg;end]中的元素赋值给c |
| c1.swap(c2) | 将c1和c2的元素互换 |
| swap(c1,c2) | 将c1和c2的元素互换，全局函数 |
| c.insert(pos,elem) | 在pos位置插入一个elem副本，并返回新元素的位置 |
| c.insert(pos,n,elem) | 在pos位置插入elem的n个副本，无返回值 |
| c.inser(pos,beg,end) | 在pos位置插入区间[beg;end)所有元素的副本，无返回值 |
| c.push_back(elem) | 在尾部添加elem的一个副本 |
| c.pop_back() | 移除最后一个元素（但不回传） |
| c.push_front(elem) | 在头部插入elem的一个副本 |
| c.pop_front() | 移除头部元素（但不回传） |
| c.erase(pos) | 移除pos位置上的元素，返回下一元素位置 |
| c.erase(beg,end) | 移除[beg;end)区间内的所有元素，返回下一元素位置 |
| c.resize(num) | 将大小（元素个数）改为num。如果size（）增长了，新增的元素都以default构造函数产生出来 |
| c.resize(num,elem) | 将大小（元素个数）改为num。如果size()增长了，新增的元素都是elem的副本 |
| c.clear() | 移除所有元素，将容器清空 |
|
list的构造函数和析构函数
| |
| 操作 | 效果 |
| – | – |
| list<Elem> c | 产生一个空的list |
| list<Elem> c1(c2) | 产生一个与c2同型的list（每个元素都被复制） |
| list<Elem> c(n) | 产生拥有n个元素的list，这些元素都以default构造函数初始化 |
| list<Elem> c(n,elem) | 产生拥有n个元素的list，每个元素都是elem的副本 |
| list<Elem> c(beg,end) | 产生一个list并以[beg;end]区间内的元素为初值 |
| c.~list<Elem>() | 销毁所有元素，释放内存 |
|
list的非变动性操作
| |
| 操作 | 效果 |
| – | – |
| c.size() | 返回元素个数 |
| c.empty() | 判断容器大小是否为零 |
| c.max_size() | 返回元素的最大可能数量 |
| c1==c2 | 判断是否c1等于c2 |
| c1!=c2 | 判断是否c1不等于c2 |
| c1<c2 | 判断是否c1小于c2 |
| c1>c2 | 判断是否c1大于c2 |
| c1<=c2 | 判断c1是否小于等于c2 |
| c1>=c2 | 判断c1是否大于等于c1 |
|
List的assignment（赋值）操作函数
| |
| 操作 | 效果 |
| – | – |
| c1=c2 | 将c2的全部元素赋值给c1 |
| c.assign(n,elem) | 将elem的n个拷贝赋值给c |
| c.assign(beg,end) | 将区间[beg;end)的元素赋值给c |
| c1.swap(c2) | 将c1和c2的元素互换 |
| swap(c1,c2) | 将c1和c2的元素互换，此为全局函数 |
|
List元素的直接存取
| |
| 操作 | 效果 |
| – | – |
| c.front() | 返回第一个元素。不检查元素是否存在 |
| c.back() | 返回最后一个元素。不检查元素是否存在 |
|
List的迭代器相关函数
| |
| 操作 | 效果 |
| – | – |
| c.begin() | 返回一个双向迭代器，指向第一个元素 |
| c.end() | 返回一个双向迭代器，指向最后元素的下一个位置 |
| c.rbegin() | 返回一个逆向迭代器，指向逆向迭代的第一个元素 |
| c.rend() | 返回一个逆向迭代器，指向逆向迭代的最后元素的下一位置 |
|
List的安插、移除操作函数
| |
| 操作 | 效果 |
| – | – |
| c.insert(pos,elem) | 在迭代器pos所指位置上安插一个elem副本，并返回新元素位置 |
| c.insert(pos,n,elem) | 在迭代器pos所指位置安插n个elem副本，无返回值 |
| c.insert(pos,beg,end) | 在迭代器pos所指位置上安插[beg;end]区间内的所有元素，无返回值 |
| c.push_back(elem) | 在尾部追加一个elem副本 |
| c.pop_back() | 移除最后一个元素（但不返回） |
| c.push_front(elem) | 在头部安插一个elem副本 |
| c.pop_front() | 移除第一元素（但不返回） |
| c.remove(val) | 移除所有其值为val的元素 |
| c.remove_if(op) | 移除所有“造成op(elem)结果为true”的元素 |
| c.erase(pos) | 移除迭代器pos所指元素，返回下一元素位置 |
| c.erase(beg,end) | 移除区间[beg;end]内的所有元素，返回下一元素位置 |
| c.resize(num) | 将元素容量变为num。如果size()变大，则以default构造函数构造所有新增元素 |
| c.resize(num,elem) | 将元素容量变为num。如果size()变大，则以elem副本作为新增元素的初值 |
| c.clear() | 移除全部元素，将整个容器清空 |
|
List的特殊变动性操作（Special Modifying Operatrion）
| |
| 操作 | 效果 |
| – | – |
| c.unique() | 如果存在若干相邻而数值相等的元素，就移除重复元素，只留下一个 |
| c.unique(op) | 如果存在若干相邻元素，都使op()的结果为true，则移除重复元素，只留下一个 |
| c1.splice(pos,c2) | 将c2内的所有元素转移到c1之内，迭代器pos之前 |
| c1.splice(pos,c2,c2pos) | 将c2内的c2pos所指元素转移到c1内的pos所指位置上（c1和c2可相同） |
| c1.splice(pos,c2,c2beg,c2end) | 将c2内的[c2beg;c2end]区间内所有元素转移到c1内的pos之前（c1和c2可相同） |
| c.sort() | 以operator<为准则，对所有元素排序 |
| c.sor(op) | 以op()为准则，对所有元素排序 |
| c1.merge(c2) | 假设c1和c2容器都包含已序（sorted）元素，将c2的全部元素转移到c1，并保证合并后的list仍为已序 |
| c1.merge(c2,op) | 假设c1和c2容器都包含op()原则下的已序（sorted）元素，将c2的全部元素转移到c1，并保证合并后的list在op()原则下仍为已序 |
| c.reverse() | 将所有元素反序（reverse the order） |
|
Lists的各种操作在异常发生时提供的特殊保证
| |
| 操作 | 效果 |
| – | – |
| push_back() | 如果不成功，就是无任何作用 |
| push_front() | 如果不成功，就是无任何作用 |
| insert() | 如果不成功，就是无任何作用 |
| pop_back() | 不抛出异常 |
| pop_front() | 不抛出异常 |
| erase() | 不抛出异常 |
| clear() | 不抛出异常 |
| resize() | 如果不成功，就是无任何作用 |
| remove() | 只要元素比较操作不抛出异常，它就不抛出异常 |
| remove_if() | 只要判断式predicate不抛出异常，它就不抛出异常 |
| unique() | 只要元素比较操作不抛出异常，它就不抛出异常 |
| splice() | 不抛出异常 |
| merge() | 只要元素比较时不抛出异常，它便保证“要么不成功，要么无任何作用” |
| reverse() | 不抛出异常 |
| swap() | 不抛出异常 |
|
Sets和Multisets的构造函数和析构函数
| |
| 操作 | 效果 |
| – | – |
| set c | 产生一个空的set/multiset，其中不含任何元素 |
| set c(op) | 以op为排序准则，产生一个空的set/multiset |
| set c1(c2) | 产生某个set/multiset的副本，所有元素均被复制 |
| set c(beg,end) | 以区间[beg;end]内的元素产生一个set/multiset |
| set c(beg,end,op) | 以op为排序基准，利用[beg;end]内的元素生成一个set/multiset |
| c.~set() | 销毁所有元素，释放内存 |
|
set的形式
| |
| 操作 | 效果 |
| – | – |
| set<Elem> | 一个set，以less<>（operator<）为排序准则 |
| set<Elem,op> | 一个set，以op为排序准则 |
| multiset<Elem> | 一个multiset，以less<>(operator<)为排序准则 |
| multiset<Elem,op> | 一个multiset，以op为排序准则 |
|
Sets和Multisets的非变动性操作（Nonmodifying Operations）
| |
| 操作 | 效果 |
| – | – |
| c.size() | 返回容器的大小 |
| c.empty() | 判断容器大小是否为零。等同于size()==0，但可能更快 |
| c.max_size() | 返回可容纳的最大元素数量 |
| c1==c2 | 判断是否c1等于c2 |
| c1!=c2 | 判断是否c1不等于c2 |
| c1<c2 | 判断是否c1小于c2 |
| c1>c2 | 判断是否c1大于c2 |
| c1<=c2 | 判断是否c1小于等于c2 |
| c1>=c2 | 判断是否c1大于等于c2 |
|
Sets和Multisets的搜寻操作函数
| |
| 操作 | 效果 |
| – | – |
| count(elem) | 返回“元素值为elem”的元素个数 |
| find(elem) | 返回“元素值为elem”的第一个元素，如果找不到就返回end() |
| lower_bound(elem) | 返回elem的第一个可安插位置，也就是“元素>=elem”的第一个元素位置 |
| upper_bound(elem) | 返回elem的最后一个可安插位置，也就是“元素值>elem”的第一个元素位置 |
| equal_bound(elem) | 返回elem可安插的第一个位置和最后一个位置，也就是“元素值==elem”的元素区间 |
|
Sets和Multisets的赋值操作
| |
| 操作 | 效果 |
| – | – |
| c1=c2 | 将c1中所有元素赋值给c1 |
| c1.swap(c2) | 将c1和c2的元素互换 |
| swap(c1,c2) | 将c1和c2的元素互换，此为全局函数 |
|
Sets和Multisets的迭代器相关操作函数
| |
| 操作 | 效果 |
| – | – |
| c.begin() | 返回一个双向迭代器（将元素视为常数），指向第一元素 |
| c.end() | 返回一个双向迭代器（将元素视为常数），指向最后元素的下一位置 |
| c.rbegin() | 返回一个逆向迭代器，指向逆向遍历时的第一元素 |
| c.rend() | 返回一个逆向迭代器，指向逆向遍历的最后元素的下一位置 |
|
Sets和Multisets的元素安插和移除
| |
| 操作 | 效果 |
| – | – |
| c.inset(elem) | 安插一份elem副本，返回新元素位置（不论是否成功-对sets而言） |
| c.insert(pos,elem) | 安插一份elem副本，返回新元素位置（pos是个提示，指出安插操作的搜寻起点。如果提示恰当，可大大加快速度） |
| c.insert(beg,end) | 将区间[beg;end]内所有元素的副本安插到c（无返回值） |
| c.erase(elem) | 移除“与elem相等”的所有元素，返回被移除的元素个数 |
| c.erase(pos) | 移除迭代器pos所指位置的元素，无返回值 |
| c.erase(beg,end) | 移除区间[beg;end]内的所有元素，无返回值 |
| c.clear() | 移除全部元素，将整个容器清空 |
|
Maps和Multimaps的构造函数和析构函数
| |
| 操作 | 效果 |
| – | – |
| map c | 产生一个空的map/multimap，其中不含任何元素 |
| map c(op) | 以op为排序基准，产生一个空的map/multimap |
| map c(beg,end) | 以区间[beg;end]内的元素产生一个map/multimap |
| map c1(c2) | 产生某个map/multimap的副本，所有元素均被复制 |
| map c(beg,end,op) | 以op为排序准则，利用[beg;end]内的元素生成一个map/multimap |
| c.~map() | 销毁所有元素，释放内存 |
|
map的形式
| |
| 操作 | 效果 |
| – | – |
| map<Key,Elem> | 一个map，以less<>（operator<）为排序准则 |
| map<Key,Elem,op> | 一个map，以op为排序准则 |
| multimap<Key,Elem> | 一个multimap，以less<>（operator<）为排序准则 |
| multimap<Key,Elem,op> | 一个multimap，以op为排序准则 |
|
Maps和Multimaps的非变动性操作（Nonmodifying Operation）
| |
| 操作 | 效果 |
| – | – |
| c.size() | 返回容器的大小 |
| c.empty() | 判断容器大小是否为零 |
| c.max_size() | 返回容器的最大元素数量 |
| c1==c2 | 判断是否c1等于c2 |
| c1!=c2 | 判断是否c1不等于c2 |
| c1<c2 | 判断是否c1小于c2 |
| c1>c2 | 判断是否c1大于c2 |
| c1<=c2 | 判断是否c1小于等于c2 |
| c1>=c2 | 判断是否c1大于等于c2 |
|
Maps和Multimaps的特殊搜寻操作函数
| |
| 操作 | 效果 |
| – | – |
| count(Key) | 返回“键值等于Key”的元素个数 |
| find(Key) | 返回“键值等于Key”的第一个元素，找不到就返回end() |
| lower_bound(Key) | 返回“键值为Key”之元素的第一个可安插位置，也就是“键值>=Key”的第一个元素位置 |
| upper_bound(Key) | 返回“键值为Keyl”之元素的最后一个可安插位置，也就是“键值>Key”的第一个元素位置 |
| equal_range(Key) | 返回“键值为Key”之元素的第一个可安插位置和最后一个可安插位置，也就是键值“== key”的元素区间 |
|
Maps和Multimaps的赋值（赋值）操作
| |
| 操作 | 效果 |
| – | – |
| c1=c2 | 将c2中所有元素赋值给c1 |
| c1.swap(c2) | 将c1和c2的元素互换 |
| swap(c1,c2) | 将c1和c2的元素互换，此为全局函数 |
|
Maps和Multimaps的迭代器相关操作函数
| |
| 操作 | 效果 |
| – | – |
| c.begin() | 返回一个双向迭代器（key被视为常数），指向第一元素 |
| c.end() | 返回一个双向迭代器（key被视为常数），指向最后元素的下一位置 |
| c.rbegin() | 返回一个逆向迭代器，指向逆向遍历时的第一个元素 |
| c.rend() | 返回一个逆向迭代器，指向逆向遍历时的最后元素的下一位置 |
|
Maps和Multimaps的元素安插和移除
| |
| 操作 | 效果 |
| – | – |
| c.insert(elem) | 安插一份elem副本，返回新元素位置（不论是否成功-对maps而言） |
| c.insert(pos,elem) | 安插一份elem副本，返回新元素位置（pos是个提示，指出安插操作的搜寻起点。如果提示恰当，可大大加快速度） |
| c.insert(beg,end) | 将区间[beg;end]内所有元素的副本安插到c（无返回值） |
| c.erase(elem) | 移除“实值（value）与elem相等”的所有元素，返回被移除元素个数 |
| c.erase(pos) | 移除迭代器pos所指位置上的元素，下一个位置 |
| c.erase(beg,end) | 移除区间[beg;end]内的所有元素，无返回值 |
| c.clear() | 移除全部元素，将整个容器清空 |
|
Maps的直接元素存取（透过operator[]）
| |
| 操作 | 效果 |
| – | – |
| m[key] | 返回一个reference，指向键值为key的元素。如果该元素尚未存在，就安插该元素 |
|
各种容器提供的迭代器类型
| |
| 容器 | 迭代器类型（iterator category） |
| – | – |
| Vector | 随机存取 |
| Deque | 随机存取 |
| List | 双向 |
| Set | 双向，元素为常量 |
| Multiset | 双向，元素为常量 |
| Map | 双向，元素为常量 |
| Multimap | 双向，元素为常量 |
| String | 随机存取 |
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
