STL速查

容器 (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.csdn.net/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); ------尾部插入元素ele
pop_back(); ------删除最后一个元素
insert(const_iterator pos, ele); ------迭代器指向位置pos插入元素ele
erase(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); // 将指定范围内的元素填充为指定值