容器 (Containers)
图解容器
支持随机访问
| string | array | vector | deque |
|---|---|---|---|
| 支持 | 支持 | 支持 | 支持 |
string 类
构造函数
string();------创建一个空的字符串 例如: string str;string(const char* s);------使用字符串s初始化string(const string& str);------拷贝构造
赋值操作
string& operator=(const string &s);------把字符串s赋给当前的字符串
字符串拼接
string& operator+=(const string& str);------重载+=操作符string& append(const string &s);------同operator+=(const string& str)
子串
string substr(int pos = 0, int n = npos) const;------返回由pos开始的n个字符组成的字符串
字符串比较
比较方式：按字符的ASCII码进行对比，主要用于比较两个字符串是否相同，相同则返回0
int compare(const string &s) const;------与字符串s比较int compare(const char *s) const;------与字符串s比较
查找和替换
find 和 rfind 方法找不到返回 -1
int find(const string& str, int pos = 0) const;------查找str第一次出现位置,从pos开始查找int rfind(const string& str, int pos = npos) const;------查找str最后一次位置,从pos开始查找string& replace(int pos, int n, const string& str);------替换从pos开始n个字符为字符串str
字符串存取
char& operator[](int n);------通过[]方式取字符char& at(int n);------通过at方法获取字符
插入和删除
string& insert(int pos, const string& str);------插入字符串string& erase(int pos, int n = npos);------删除从Pos开始的n个字符
array 容器 (静态数组)
- 推荐阅读一：https://www.cnblogs.com/zhangnianyong/p/11882672.html
- 推荐阅读二：https://blog.youkuaiyun.com/qq_37529913/article/details/118688364
vector 容器 (动态数组)
普通查找
构造函数
vector<T> v;------采用模板实现类实现，默认构造函数vector(n, elem);------构造函数将n个elem拷贝给本身vector(const vector &vec);------拷贝构造函数
赋值和交换
vector& operator=(const vector &vec);------重载等号操作符swap(vec);------ 将vec与本身的元素互换，可用于收缩内存vector<int>(v).swap(v); ------匿名对象
容量和大小
empty();------判断容器是否为空capacity();------容器的容量size();------返回容器中元素的个数resize(int num);------重新指定容器的长度为num，若容器变长，则以默认值填充新位置如果容器变短，则末尾超出容器长度的元素被删除resize(int num, elem);------重新指定容器的长度为num，若容器变长，则以elem值填充新位置如果容器变短，则末尾超出容器长度的元素被删除
插入和删除
push_back(ele);------尾部插入元素elepop_back();------删除最后一个元素insert(const_iterator pos, ele);------迭代器指向位置pos插入元素eleerase(const_iterator pos);------删除迭代器指向的元素clear();------删除容器中所有元素
数据存取
at(int idx);------返回索引idx所指的数据operator[];------返回索引idx所指的数据front();------返回容器中第一个数据元素back();------返回容器中最后一个数据元素
预留空间
reserve(int len);------容器预留len个元素长度，预留位置不初始化，元素不可访问，数据量较大时可用于减少vector在动态扩展容量时的扩展次数
代码查找
#include <vector>
vector容器的构造函数
vector<T> v; // 采用模板类实现，默认构造函数
vector(v.begin(), v.end()); // 将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem); // 构造函数将n个elem拷贝给本身。
vector(const vector& vec); // 拷贝构造函数。
vector容器的赋值操作
assign(const_iterator start, const_iterator end); // 将[start, end)区间中的数据拷贝赋值给本身。
assign(int n, const T& elem); // 将n个elem拷贝赋值给本身。
vector& operator=(const vector& vec); // 重载等号操作符
vector容器的大小操作
v.empty(); // 判断容器是否为空
v.size(); // 返回容器中元素的个数
v.resize(int num); // 重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
v.resize(int num, const T& elem); // 重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
vector容器的插入和删除操作
v.push_back(elem); // 在容器尾部加入一个元素
v.pop_back(); // 删除容器中最后一个元素
v.insert(const_iterator pos, const T& elem); // 在pos位置插入一个elem元素的拷贝，返回新数据的位置。
v.insert(const_iterator pos, int count, const T& elem); // 在pos位置插入count个elem数据，无返回值。
v.erase(const_iterator pos); // 删除pos位置的数据，返回下一个数据的位置。
v.erase(const_iterator start, const_iterator end); // 删除[start, end)区间的数据，返回下一个数据的位置。
v.clear(); // 移除容器的所有数据
vector容器的数据存取
v.at(int idx); // 返回索引idx所指的数据，如果idx越界，抛出out_of_range。
v[idx]; // 返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
v.front(); // 返回容器中第一个数据元素
v.back(); // 返回容器中最后一个数据元素
vector互换
v.swap(v1); // 将v与v1的元素互换
vector的预留空间
v.reserve(int len); // 容器预留len个元素长度，预留位置不初始化，元素不可访问。
vector的反转操作
reverse(iterator start, iterator end); // 将[start, end)区间中的数据反转
vector的排序
sort(iterator start, iterator end); // 对[start, end)区间中的数据进行排序
sort(iterator start, iterator end, _Pred); // 对[start, end)区间中的数据进行排序，指定排序规则,_Pred是自定义的谓词，可以是函数指针，函数对象，函数，Lambda表达式等。
sort()成员函数使用的是快速排序算法。
vector的迭代器
v.begin(); // 返回容器中第一个数据的迭代器。
v.end(); // 返回容器中最后一个数据之后的迭代器。
v.rbegin(); // 返回容器中倒数第一个元素的迭代器。
v.rend(); // 返回容器中倒数最后一个元素的后面的迭代器。
v.cbegin(); // 返回容器中第一个数据的const迭代器。
v.cend(); // 返回容器中最后一个数据之后的const迭代器。
v.crbegin(); // 返回容器中倒数第一个元素的const迭代器。
v.crend(); // 返回容器中倒数最后一个元素的后面的const迭代器。
list 容器 (双向循环链表)
普通查找
List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的
构造函数
list<T> lst;------list采用采用模板类实现,对象的默认构造形式：list(n,elem);------构造函数将n个elem拷贝给本身list(const list &lst);------拷贝构造函数
赋值和交换
list& operator=(const list &lst);------重载等号操作符swap(lst);------将lst与本身的元素互换
容量和大小
size();------返回容器中元素的个数empty();------判断容器是否为空resize(num);------重新指定容器的长度为num，若容器变长，则以默认值填充新位置如果容器变短，则末尾超出容器长度的元素被删除resize(num, elem);------重新指定容器的长度为num，若容器变长，则以elem值填充新位置
插入和删除
push_back(elem);------在容器尾部加入一个元素pop_back();------删除容器中最后一个元素push_front(elem);------在容器开头插入一个元素pop_front();------从容器开头移除第一个元素insert(pos,elem);------在pos位置插elem元素的拷贝，返回新数据的位置clear();------移除容器的所有数据erase(pos);------删除pos位置的数据，返回下一个数据的位置remove(elem);------删除容器中所有与elem值匹配的元素
数据存取
front();------返回第一个元素back();------返回最后一个元素
反转和排序
reverse();------反转链表sort();------链表排序sort(MyCompare);------使用仿函数自定义排序规则
class MyCompare
{
public:
bool operator()(int v1, int v2) {
return v1 > v2; ------升序
}
};
sort(ComparePerson);------若list存放自定义数据类型，排序时必须指定排序规则
bool ComparePerson(Person& p1, Person& p2) {
if (p1.m_Age == p2.m_Age) {
return p1.m_Height > p2.m_Height; ------如果年龄相同按照身高降序
}
else{
return p1.m_Age < p2.m_Age; ------按照年龄进行升序
}
}
代码查找
#include<list>
list容器的构造函数
list<T> lst; // 默认构造函数
list(int n, const T& val = T()); // 构造函数将n个val拷贝给本身。
list(InputIterator first, InputIterator last); // 构造函数将区间[first, last)中的数据拷贝给本身。
list(const list& lst); // 拷贝构造函数
list容器的赋值操作
assign(InputIterator first, InputIterator last); // 将区间[first, last)中的数据拷贝赋值给本身。
list& operator=(const list& lst); // 重载等号操作符
lst.swap(list& lst); // 将lst与lst的元素互换
list容器的大小操作
lst.empty(); // 判断容器是否为空
lst.size(); // 返回容器中元素的个数
lst.resize(int num); // 重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
lst.resize(int num, const T& val); // 重新指定容器的长度为num，若容器变长，则以val值填充新位置。
lst.clear(); // 清空所有数据
list容器的数据存取
lst.front(); // 返回第一个数据
lst.back(); // 返回最后一个数据
list容器的插入和删除操作
lst.push_back(); // 在容器尾部加入一个数据
lst.pop_back(); // 删除容器中最后一个数据
lst.push_front(); // 在容器开头插入一个数据
lst.pop_front(); // 从容器开头移除第一个数据
lst.insert(iterator position, int n, const T& val); // 在position位置插入n个val数据，返回指向第一个插入数据的迭代器。
lst.insert(iterator position, const T& val); // 在position位置插入val数据，返回指向插入数据的迭代器。
lst.insert(iterator position, InputIterator first, InputIterator last); // 在position位置插入区间[first, last)中的数据，返回指向第一个插入数据的迭代器。
lst.erase(iterator position); // 删除position位置的数据，返回下一个数据的迭代器。
lst.erase(iterator first, iterator last); // 删除区间[first, last)中的数据，返回指向被删除数据之后的迭代器。
lst.remove(val); // 删除容器中所有与val值匹配的元素。
lst.remove_if(_Pred); // 删除容器中满足条件_Pred的元素。
lst.unique(); // 删除容器中相邻的重复元素。
list容器的反转和排序
lst.reverse(); // 反转链表
lst.sort(); // 链表排序
deque 容器 (双端队列)
普通查找
构造函数
deque<T> deq; ------默认构造形式deque(n, elem);------构造函数将n个elem拷贝给本身deque(const deque &deq);------拷贝构造函数
赋值和交换
deque& operator=(const deque &deq);------重载等号操作符swap(deq);------将deq与本身的元素互换
容量和大小
deque.empty();------判断容器是否为空deque.size();------返回容器中元素的个数deque.resize(num);------重新指定容器的长度为num,若容器变长，则以默认值填充新位置如果容器变短，则末尾超出容器长度的元素被删除deque.resize(num, elem);------重新指定容器的长度为num,若容器变长，则以elem值填充新位置如果容器变短，则末尾超出容器长度的元素被删除
插入和删除
push_back(elem);------在容器尾部添加一个数据push_front(elem);------在容器头部插入一个数据pop_back();------删除容器最后一个数据pop_front();------删除容器第一个数据insert(pos,elem);------在pos位置插入一个elem元素的拷贝，返回新数据的位clear();------清空容器的所有数据erase(pos);------删除pos位置的数据，返回下一个数据的位置
数据存取
at(int idx);------返回索引idx所指的数据operator[];------返回索引idx所指的数据front();------返回容器中第一个数据元素back();------返回容器中最后一个数据元素
代码查找
#include <deque>
deque容器的构造函数
deque() deq; // 默认构造函数
deque(int n, value); // 构造函数将n个value拷贝给本身。
deque(const deque& deq); // 拷贝构造函数
deque容器的赋值操作
deq.assign(const_iterator start, const_iterator end); // 将[start, end)区间中的数据拷贝赋值给本身。
deq.assign(int n, const T& val); // 将n个val拷贝赋值给本身。
deq.deque& operator=(const deque& deq); // 重载等号操作符
deque容器的大小操作
deq.empty(); // 判断容器是否为空
deq.size(); // 返回容器中元素的个数
deq.resize(int num); // 重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
deq.resize(int num, const T& val); // 重新指定容器的长度为num，若容器变长，则以val值填充新位置。
deq.shrink_to_fit(); // 请求移除deque中未使用的容量
deque容器的插入和删除操作
deq.push_back(elem); // 在容器尾部添加一个数据
deq.push_front(elem); // 在容器头部插入一个数据
deq.pop_back(); // 删除容器最后一个数据
deq.pop_front(); // 删除容器第一个数据
deq.insert(const_iterator it, const T& val); // 在it位置插入一个val的拷贝，返回新数据的位置。
deq.insert(const_iterator it, int count, const T& val); // 在it位置插入count个val数据，无返回值。
deq.insert(const_iterator it, const_iterator first, const_iterator last); // 在it位置插入[first, last)区间的数据，无返回值。
deq.erase(const_iterator it); // 删除it位置的数据，返回下一个数据的位置。
deq.erase(const_iterator first, const_iterator last); // 删除[first, last)区间的数据，返回下一个数据的位置。
deq.clear(); // 清空容器的所有数据
deque容器的数据存取
deq.at(int idx); // 返回索引idx所指的数据，如果idx越界，抛出out_of_range。
deq[idx]; // 返回索引idx所指的数据，如果idx越界，直接出错。
deq.front(); // 返回第一个数据。
deq.back(); // 返回最后一个数据
deque容器的迭代器
deq.begin(); // 返回指向第一个数据的迭代器。
deq.end(); // 返回指向最后一个数据的下一个迭代器。
deq.rbegin(); // 返回指向最后一个数据的迭代器。
deq.rend(); // 返回指向第一个数据的前一个迭代器。
deq.cbegin(); // 返回指向第一个数据的const迭代器。
deq.cend(); // 返回指向最后一个数据的下一个const迭代器。
deq.crbegin(); // 返回指向最后一个数据的const迭代器。
deq.crend(); // 返回指向第一个数据的前一个const迭代器。
deque容器的互换
deq.swap(deque& other); // 将deq与other的元素互换
deque容器的排序
std::sort(iterator start, iterator end); // 对[start, end)区间中的数据进行排序
std::sort(iterator start, iterator end, _Pred); // 对[start, end)区间中的数据进行排序，指定排序规则,_Pred是自定义的谓词，可以是函数指针，函数对象，函数，Lambda表达式等。
queue 容器 (队列)
普通查找
构造函数
queue<T> que;------queue采用模板类实现，queue对象的默认构造形式queue(const queue &que);------拷贝构造函数
赋值和交换
queue& operator=(const queue &que);------重载等号操作符swap(que);------将que与本身的元素互换
容量和大小
empty();------判断堆栈是否为空size();------返回栈的大小
插入和删除
push(elem);------往队尾添加元素pop();------从队头移除第一个元素
数据存取
back();------返回最后一个元素front();------返回第一个元素
代码查找
#include <queue>
queue容器的构造函数
queue<T> que; // 默认构造函数
queue(const queue& que); // 拷贝构造函数
queue容器的赋值操作
queue& operator=(const queue& que); // 重载等号操作符
queue容器的大小操作
que.empty(); // 判断队列是否为空
que.size(); // 返回队列中元素的个数
queue容器的数据存取
que.front(); // 返回队列第一个元素
que.back(); // 返回队列最后一个元素
que.push(); // 向队列尾部添加元素
que.pop(); // 从队列头部移除元素
queue容器的互换
que.swap(queue& que); // 将que与que的元素互换
priority_queue容器的构造函数
priority_queue<T> pque; // 默认构造函数
priority_queue容器的赋值操作
priority_queue& operator=(const priority_queue& pque); // 重载等号操作符
priority_queue容器的大小操作
pque.empty(); // 判断队列是否为空
pque.size(); // 返回队列中元素的个数
priority_queue容器的数据存取
pque.top(); // 返回队列中优先级最高的元素
pque.push(); // 向队列中添加元素
pque.pop(); // 从队列中移除优先级最高的元素
priority_queue容器的互换
pque.swap(priority_queue& pque); // 将pque与pque的元素互换
stack 容器 (栈)
普通查找
构造函数
stack<T> stk;------stack采用模板类实现， stack对象的默认构造形式stack(const stack &stk);------拷贝构造函数
赋值和交换
stack& operator=(const stack &stk);------重载等号操作符swap(stk);------将stk与本身的元素互换
容量和大小
empty();------判断堆栈是否为空size();------返回栈的大小
插入和删除
push(elem);------向栈顶添加元素pop();------从栈顶移除第一个元素
数据存取
top();------返回栈顶元素
代码查找
#include <stack>
stack容器的构造函数
stack<T> stk; // 默认构造函数
stack(const stack& stk); // 拷贝构造函数
stack容器的赋值操作
stack& operator=(const stack& stk); // 重载等号操作符
stack容器的大小操作
stk.empty(); // 判断堆栈是否为空
stk.size(); // 返回堆栈中元素的个数
stack容器的数据存取
stk.top(); // 返回栈顶元素
stk.push(); // 向栈顶添加元素
stk.pop(); // 从栈顶移除元素
stack容器的互换
stk.swap(stack& stk); // 将stk与stk的元素互换
set/multiset 容器 (集合)
普通查找
set 集合 / multiset 允许重复集合
构造函数
set<T> st;------默认构造函数：set(const set &st);------拷贝构造函数
赋值和交换
set& operator=(const set &st);------重载等号操作符swap(st);------交换两个集合容器
容量和大小
size();------返回容器中元素的数目empty();------判断容器是否为空
插入和删除
insert(elem);------在容器中插入元素clear();------清除所有元素erase(pos);------删除pos迭代器所指的元素，返回下一个元素的迭代器erase(elem);------删除容器中值为elem的元素
查找和计数
find(key);------查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();count(key);------统计key的元素个数(对于set结果为0或1)
区别
- set不可以插入重复数据，而multiset可以
- set插入数据的同时会返回插入结果，表示插入是否成功
- multiset不会检测数据，因此可以插入重复数据
set 排序
插入元素时自动排序，默认为从小到大，可在定义容器时使用仿函数自定义排序规则
set<int, MyCompare> s;------Mycompare是自定义的类，类内重载了()
class MyCompare
{
public:
bool operator()(int v1, int v2) {
return v1 > v2; ------升序
}
};
set<Person, comparePerson> s;------set存放自定义数据类型，必须指定排序规则
bool ComparePerson(Person& p1, Person& p2) {
if (p1.m_Age == p2.m_Age) {
return p1.m_Height > p2.m_Height; ------如果年龄相同按照身高降序
}
else{
return p1.m_Age < p2.m_Age; ------按照年龄进行升序
}
}
代码查找
#include <set>
set容器的构造函数
set<T> st; // 默认构造函数
set(const set& st); // 拷贝构造函数
multiset容器的构造函数
multiset<T> mst; // 默认构造函数
multiset(const multiset& mst); // 拷贝构造函数
set容器的赋值操作
set& operator=(const set& st); // 重载等号操作符
multiset容器的赋值操作
multiset& operator=(const multiset& mst); // 重载等号操作符
set容器的大小操作
st.empty(); // 判断容器是否为空
st.size(); // 返回容器中元素的个数
st.max_size(); // 返回容器能容纳元素的最大个数
multiset容器的大小操作
mst.empty(); // 判断容器是否为空
mst.size(); // 返回容器中元素的个数
mst.max_size(); // 返回容器能容纳元素的最大个数
set容器的插入和删除操作
st.insert(const value_type& val); // 在容器中插入元素
st.insert(const_iterator position, const value_type& val); // 将val插入到position位置尽可能近的位置
st.erase(const_iterator position); // 删除position迭代器所指的元素
st.erase(const value_type& val); // 删除容器中值为val的元素
st.erase(first, last); // 删除区间[first, last)中的所有元素
st.clear(); // 清空所有元素
multiset容器的插入和删除操作
mst.insert(const value_type& val); // 在容器中插入元素
mst.insert(const_iterator position, const value_type& val); // 将val插入到position位置尽可能近的位置
mst.erase(const_iterator position); // 删除position迭代器所指的元素
mst.erase(const value_type& val); // 删除容器中值为val的元素
mst.erase(first, last); // 删除区间[first, last)中的所有元素
mst.clear(); // 清空所有元素
set容器的查找操作
st.find(const value_type& val); // 查找值为val的元素，找到返回该元素的迭代器，找不到返回end迭代器
st.count(const value_type& val); // 返回容器中值为val的元素个数
st.lower_bound(const value_type& val); // 返回第一个>=val元素的迭代器
st.upper_bound(const value_type& val); // 返回第一个>val元素的迭代器
st.equal_range(const value_type& val); // 返回容器中与val相等的上下限的两个迭代器
multiset容器的查找操作
mst.find(const value_type& val); // 查找值为val的元素，找到返回该元素的迭代器，找不到返回end迭代器
mst.count(const value_type& val); // 返回容器中值为val的元素个数
mst.lower_bound(const value_type& val); // 返回第一个>=val元素的迭代器
mst.upper_bound(const value_type& val); // 返回第一个>val元素的迭代器
mst.equal_range(const value_type& val); // 返回容器中与val相等的上下限的两个迭代器
set容器的迭代器
st.begin(); // 返回指向第一个元素的迭代器
st.end(); // 返回末尾的迭代器
st.rbegin(); // 返回指向最后一个元素的迭代器
st.rend(); // 返回指向第一个元素的迭代器
st.cbegin(); // 返回指向第一个元素的const迭代器
st.cend(); // 返回末尾的const迭代器
st.crbegin(); // 返回指向最后一个元素的const迭代器
st.crend(); // 返回指向第一个元素的const迭代器
multiset容器的迭代器
mst.begin(); // 返回指向第一个元素的迭代器
mst.end(); // 返回末尾的迭代器
mst.rbegin(); // 返回指向最后一个元素的迭代器
mst.rend(); // 返回指向第一个元素的迭代器
mst.cbegin(); // 返回指向第一个元素的const迭代器
mst.cend(); // 返回末尾的const迭代器
mst.crbegin(); // 返回指向最后一个元素的const迭代器
mst.crend(); // 返回指向第一个元素的const迭代器
set容器的互换
st.swap(set& st); // 将st与st的元素互换
multiset容器的互换
mst.swap(multiset& mst); // 将mst与mst的元素互换
map/multimap 容器 (映射)
map映射 / multimap 允许重复映射
普通查找
pair 构造
pair<type, type> p ( value1, value2 );pair<type, type> p = make_pair( value1, value2 );
pair 存取
p.first;访问/修改第一个元素p.second;访问/修改第二个元素
构造函数
map<T1, T2> mp;------map默认构造函数:map(const map &mp);------拷贝构造函数
赋值和交换
map& operator=(const map &mp);------重载等号操作符swap(st);------交换两个集合容器
容量和大小
size();------返回容器中元素的数目empty();------判断容器是否为空
插入和删除
insert(elem);------在容器中插入元素clear();------清除所有元素erase(pos);------删除pos迭代器所指的元素，返回下一个元素的迭代器erase(key);------删除容器中值为key的元素
查找和计数
find(key);------查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();count(key);------统计key的元素个数(对于map结果为0或1)
map 排序
插入键值对时自动排序，默认为按key值从小到大，可在定义容器时使用仿函数自定义排序规则
map<int, int, MyCompare> m;------此处的MyCompare为自定义排序规则，同set容器map<Person, int, comparePerson> s;------若键值为自定义数据类型(少用)，必须指定排序规则，同set容器
代码查找
#include <map>
map容器的构造函数
map<T1, T2> mp; // 默认构造函数
map(const map& mp); // 拷贝构造函数
multimap容器的构造函数
multimap<T1, T2> mmp; // 默认构造函数
multimap(const multimap& mmp); // 拷贝构造函数
map容器的赋值操作
map& operator=(const map& mp); // 重载等号操作符
multimap容器的赋值操作
multimap& operator=(const multimap& mmp); // 重载等号操作符
map容器的大小操作
mp.empty(); // 判断容器是否为空
mp.size(); // 返回容器中元素的个数
mp.max_size(); // 返回容器能容纳元素的最大个数
multimap容器的大小操作
mmp.empty(); // 判断容器是否为空
mmp.size(); // 返回容器中元素的个数
mmp.max_size(); // 返回容器能容纳元素的最大个数
map容器的插入和删除操作
mp.insert(const value_type& val); // 在容器中插入元素
mp.insert(const_iterator position, const value_type& val); // 将val插入到position位置尽可能近的位置
mp.erase(const_iterator position); // 删除position迭代器所指的元素
mp.erase(const value_type& val); // 删除容器中值为val的元素
mp.erase(first, last); // 删除区间[first, last)中的所有元素
mp.clear(); // 清空所有元素
multimap容器的插入和删除操作
mmp.insert(const value_type& val); // 在容器中插入元素
mmp.insert(const_iterator position, const value_type& val); // 将val插入到position位置尽可能近的位置
mmp.erase(const_iterator position); // 删除position迭代器所指的元素
mmp.erase(const value_type& val); // 删除容器中值为val的元素
mmp.erase(first, last); // 删除区间[first, last)中的所有元素
mmp.clear(); // 清空所有元素
map容器的查找操作
mp.find(const key_type& key); // 查找键为key的元素，找到返回该元素的迭代器，找不到返回end迭代器
mp.count(const key_type& key); // 返回容器中键为key的元素个数
mp.lower_bound(const key_type& key); // 返回第一个>=key元素的迭代器
mp.upper_bound(const key_type& key); // 返回第一个>key元素的迭代器
mp.equal_range(const key_type& key); // 返回容器中与key相等的上下限的两个迭代器
multimap容器的查找操作
mmp.find(const key_type& key); // 查找键为key的元素，找到返回该元素的迭代器，找不到返回end迭代器
mmp.count(const key_type& key); // 返回容器中键为key的元素个数
mmp.lower_bound(const key_type& key); // 返回第一个>=key元素的迭代器
mmp.upper_bound(const key_type& key); // 返回第一个>key元素的迭代器
mmp.equal_range(const key_type& key); // 返回容器中与key相等的上下限的两个迭代器
map容器的迭代器
mp.begin(); // 返回指向第一个元素的迭代器
mp.end(); // 返回末尾的迭代器
multimap容器的迭代器
mmp.begin(); // 返回指向第一个元素的迭代器
mmp.end(); // 返回末尾的迭代器
map容器的互换
mp.swap(map& mp); // 将mp与mp的元素互换
#include <unordered_map>
unordered_map容器的构造函数
unordered_map<T1, T2> ump; // 默认构造函数
unordered_map(const unordered_map& ump); // 拷贝构造函数
unordered_multimap容器的构造函数
unordered_multimap<T1, T2> ummp; // 默认构造函数
unordered_multimap(const unordered_multimap& ummp); // 拷贝构造函数
unordered_map容器的赋值操作
unordered_map& operator=(const unordered_map& ump); // 重载等号操作符
unordered_multimap容器的赋值操作
unordered_multimap& operator=(const unordered_multimap& ummp); // 重载等号操作符
unordered_map容器的大小操作
ump.empty(); // 判断容器是否为空
ump.size(); // 返回容器中元素的个数
ump.max_size(); // 返回容器能容纳元素的最大个数
unordered_multimap容器的大小操作
ummp.empty(); // 判断容器是否为空
ummp.size(); // 返回容器中元素的个数
ummp.max_size(); // 返回容器能容纳元素的最大个数
unordered_map容器的插入和删除操作
ump.insert(const value_type& val); // 在容器中插入元素
ump.erase(const key_type& key); // 删除容器中键为key的元素
ump.erase(const_iterator position); // 删除position迭代器所指的元素
ump.erase(const_iterator first, const_iterator last); // 删除区间[first, last)中的所有元素
ump.clear(); // 清空所有元素
算法 (Algorithms)
#include <algorithm>
仿函数
less<T> // 升序排列
greater<T> // 降序排列
plus<T> // 加法仿函数
minus<T> // 减法仿函数
multiplies<T> // 乘法仿函数
divides<T> // 除法仿函数
modulus<T> // 取模仿函数
negate<T> // 取反仿函数
普通仿函数使用格式：
仿函数名字对象(参数)
例如：
plus<int> intAdd;
intAdd(10, 20); // 等价于10+20
函数对象
函数对象是一个类，类中重载了()操作符的对象
函数对象的好处是可以像普通函数那样调用，可以有自己的状态
函数对象的调用可以有参数，也可以有返回值
函数对象可以作为参数传递给函数
函数对象可以作为函数的返回值
例如：
class MyAdd
{
public:
int operator()(int v1, int v2)
{
return v1 + v2;
}
};
MyAdd myAdd;
myAdd(10, 20); // 等价于10+20
查找算法：适用于所有容器
find(iterator start, iterator end, value); // 查找指定范围内的指定元素，找到返回指向该元素的迭代器，找不到返回end迭代器
find_if(iterator start, iterator end, _Pred); // 查找指定范围内满足条件_Pred的元素，找到返回指向该元素的迭代器，找不到返回end迭代器
adjacent_find(iterator start, iterator end); // 查找指定范围内相邻重复元素的第一个元素，找到返回指向该元素的迭代器，找不到返回end迭代器
binary_search(iterator start, iterator end, value); // 查找指定范围内是否存在指定元素，找到返回true，找不到返回false
count(iterator start, iterator end, value); // 统计指定范围内指定元素的个数
count_if(iterator start, iterator end, _Pred); // 统计指定范围内满足条件_Pred的元素的个数
排序算法：适用于所有容器
random_shuffle(iterator start, iterator end); // 对指定范围内的元素进行随机调整
sort(iterator start, iterator end); // 对指定范围内的元素进行排序
sort(iterator start, iterator end, _Pred); // 对指定范围内的元素进行排序，指定排序规则
stable_sort(iterator start, iterator end); // 对指定范围内的元素进行稳定排序
stable_sort(iterator start, iterator end, _Pred); // 对指定范围内的元素进行稳定排序，指定排序规则
拷贝和替换算法：适用于所有容器
copy(iterator start, iterator end, iterator dest); // 将指定范围内的元素拷贝到另一容器中
replace(iterator start, iterator end, old_value, new_value); // 将指定范围内的旧元素替换为新元素
replace_if(iterator start, iterator end, _Pred, new_value); // 将指定范围内满足条件_Pred的元素替换为新元素
遍历算法：适用于所有容器
for_each(iterator start, iterator end, _Func); // 对指定范围内的元素进行遍历，_Func可以是函数指针，函数对象，函数，Lambda表达式等
transform(iterator start, iterator end, dest, _Func); // 对指定范围内的元素进行转换，_Func可以是函数指针，函数对象，函数，Lambda表达式等
#include <numeric>
算数生成算法：适用于所有容器
accumulate(iterator start, iterator end, init); // 计算指定范围内的元素累计总和
fill(iterator start, iterator end, value); // 将指定范围内的元素填充为指定值
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
