C++ 常用容器成员函数用法总结

C++ 常用容器成员函数用法总结

简介

包括以下容器

array <int, 10> a; ~~~~~~~~~~~~~~~~~//# include 
string str; ~~~~~~~~~~~~~~~~~~~~~~~~//# include 
vector <int> v; ~~~~~~~~~~~~~~~~~~~~//# include 
deque <int> dv; ~~~~~~~~~~~~~~~~~~~~//# include 
list <int> l; ~~~~~~~~~~~~~~~~~~~~~~//# include 
forward_list <int> fl; ~~~~~~~~~~~~~//# include 
pair <int, int> p; ~~~~~~~~~~~~~~~~~//# include 
set <int> s; ~~~~~~~~~~~~~~~~~~~~~~~//# include 
multiset <int> ms;~~~~~~~~~~~~~~~~~~//# include 
map <int, int> m;~~~~~~~~~~~~~~~~~~~//# include 
multimap <int, int>mm;~~~~~~~~~~~~~~//# include 
unordered_set <int> us;~~~~~~~~~~~~~//# include 
unordered_multiset <int> ums;~~~~~~~//# include 
unordered_map <int, int> um;~~~~~~~~//# include 
unordered_multimap <int, int> umm;~~//# include 
stack <int> st; ~~~~~~~~~~~~~~~~~~~~//# include 
queue <int> q; ~~~~~~~~~~~~~~~~~~~~~//# include 
priority_queue <int> pq;~~~~~~~~~~~~//# include 

点击前往: array 用法详解
点击前往: string 用法详解
点击前往: vector 用法详解
点击前往: deque 用法详解
点击前往: list 用法详解
点击前往: forward_list 用法详解
点击前往: pair 用法详解
点击前往: set/multiset 用法详解
点击前往: map/multimap 用法详解
点击前往: unordered_x 用法详解
点击前往: stack 用法详解
点击前往: queue 用法详解
点击前往: priority_queue 用法详解

迭代器

分为：
begin / end
rbegin / rend
cbegin / cend
crbegin / crend
before_begin
cbefore_begin

使用方法
auto it = x.begin();//用 *it 访问\

简介

x.begin(); 返回迭代器, 指向第一元素
x.end(); 返回迭代器, 指向最末元素的下一个位置
x.cbegin(); 返回迭代器, 指向第一元素, 类型为const
x.rbegin(); 返回反向迭代器, 指向反向迭代的第一元素
x.rend(); 返回反向迭代器, 指向反向迭代的最末元素的下一个位置
x.crbegin(); 返回反向迭代器, 指向反向迭代的第一元素, 类型为const
x.before_begin(); 返回迭代器, 指向第一元素的前一个位置

begin和rbegin的区别
x.begin()返回迭代器，指向容器内的第一元素
x.rbegin()返回逆序迭代器，指向容器内的最后一个元素
x.begin(),x.begin()+1,···,x.end()-1,x.end()
x.rbegin(),x.rbegin()+1,···,x.rend()-1,x.rend()

begin和cbegin的区别
可以通过x.begin()修改容器内元素的值
不能通过x.cbegin()修改容器内元素的值

array: 静态数组

简介

头文件: # include < array >
是 C++ 为了解决 C 风格数组的问题而提供的静态数组容器, 大小设置之后固定不变, 通常比 C 风格的数组更轻、更有效、更可靠
与C风格数组的区别
只是比C风格数组多了几个容器的成员函数, 其他用法大致相同

构造函数

array <int, 9> a, a1;//定义具有 9 个 int 型元素的数组
array <char, 9> ach;//定义具有 9 个 char 型元素的数组
array <string, 9> astr;//定义具有 9 个 string 型元素数组
array <array<int, 9>, 9 > aa;//定义二维 int 类型的数组
array <int, 9> a2{ 1,2,3,4 };//定义新容器, 将 {1,2,3,4} 作为初值
array <int, 9> a3 = { 1,2,3,4 };//同上
array <int, 9> a4(a);//定义新容器 a4, 拷贝 a 所有的元素
array <int, 9> a5 = a;//同上

访问 / 赋值

迭代器

包括：begin、end、rbegin、rend、cbegin、cend、crbegin、crend

下标 / at

支持下标 [] 和 at 函数随机访问容器内元素
a[id]; 返回下标为 id 的元素, 不检查是否越界
a.at(id); 返回下标为 id 的元素, 如果越界抛出异常

批量赋值

a.assign(3);//将容器的每个元素都赋值成 3
a.fill(4);//将容器的每个元素都赋值成 4

swap (交换函数)

a.swap(a1);//交换两个容器的内容

常用函数

a.front();//返回第一元素
a.back();//返回最末元素
a.empty();//容器为空返回true, 否则返回 false

长度/空间/容量相关函数

a.size();//返回容器内目前的元素个数
a.max_size();//返回元素个数 size 的最大值

注: 由于array 是静态数组, 因此这里的 size 和 max_size 相同

string：字符串

简介

头文件: # include < string >
一个专门存储和处理字符类型的容器, 具有强大的功能

构造函数

string str, str1;
string str2("abcde");//定义新容器, 将 “abcde” 作为初值
string str3 = "abcde";//同上
string str4{ "abcde" };//同上
string str5 = { "abcde" };//同上
string str6{ 'a','b','c','d','e' };//同上
string str7(6, 's');//定义新容器, 将 6 个 ‘s’ 作为初值
string str8(str);//定义新容器 str8, 拷贝 str 所有的元素
string str9 = str;//同上
string str10(str, 2);//定义新容器 str10, 拷贝 str[2]~str[n-1]
string str11(str, 2, 3);// 定义新容器 str11, 拷贝 str[2]~str[2+3-1]
string str12(str.begin(), str.end());//定义新容器 str2, 拷贝区间内元素

访问 / 赋值

迭代器

包括：begin、end、rbegin、rend、cbegin、cend、crbegin、crend

下标 / at

支持下标 [] 和 at 函数随机访问容器内字符
str[id]; 返回下标为 id 的字符, 不检查是否越界
str.at(id); 返回下标为 id 的字符, 如果越界抛出异常

assign (赋值函数)

str.assign(6, 's');//将 6 个 ‘s’ 赋值给 str
str.assign(str1);//将 str1 赋值给 str
str.assign(str1, 2);//将 str1[2]~str1[n-1] 赋值给 str
str.assign(str1, 2, 3);//将 str1[2]~str1[2+3-1] 赋值给 str
str.assign(str1.begin(), str1.end());//将区间内的元素赋值给 str

连接符

+和 +=：连接字符串
=：字符串赋值
>、>=、< 和 <=：字符串比较 (例如a < b)
==、!=：比较字符串
<<、>>：输出、输入字符串
例: str += str1;// 在 str 末尾添加 str1

swap (交换函数)

str.swap(str1);// 交换两个容器的内容

常用函数

str.push_back('s');//在末尾添加字符 ‘s’
str.pop_back();//删除最后一个元素
str.front();//返回第一元素
str.back();//返回最末元素
str.clear();//清空容器
str.empty();//容器为空返回true, 否则返回 false

长度 / 空间 / 容量相关函数

str.length();//返回字符串 str 的长度
str.size();//返回容器内目前的元素个数
str.max_size();//返回元素个数 size 的最大值
str.resize(3);//设置 size,只影响 size,设置之后 size=3，若尺寸变小, 多余部分截掉
str.resize(3, 's');//设置 size, 如果尺寸变大，新空间全部用 ‘s’ 代替
str.capacity();//返回重新分配内存前 str 可以容纳的字符数，至少比size大,
//大小只能为：16*n-1
str.reserve(3);//设置 str 的 capacity，以保留 3 个字符空间，只影响 capacity。
//设置之后，capacity>=3

添加元素

insert (插入函数)

str.insert(2, 3, 's');//在位置之前插入 3 个字符 ‘s’
str.insert(2, "string");//在位置之前插入字符串 “string”, 返回str
str.insert(2, str1);//在位置之前插入 str1 字符串
str.insert(2, str1, 3);//在位置之前插入 str1[3]~str1[n-1]
str.insert(2, str1, 3, 4);//在位置之前插入 str1[3]~str1[3+4-1]
str.insert(str.end(), 's');//在位置之前插入字符 ‘s’, 返回新元素的第一个位置
str.insert(str.end(), 3, 's');//在位置之前插入 3 个字符 ‘s’
str.insert(str.end(), str1.begin(), str1.end());//在位置之前插入 str1 区间内的元素.

append (连接函数)

str.append(6, 's');//在 str 末尾添加 6 个字符 ‘s’
str.append(str1);// 在 str 末尾添加 str1
str.append(str1, 2);//在 str 末尾添加 str1[2]~str1[n-1]
str.append(str1, 2, 3);//在 str 末尾添加 str1[2]~str1[2+3-1]
str.append(str1.begin(),str1.end());//将 str1 区间内的元素添加到 str 末尾

删除元素

erase (删除函数)

str.erase(3);//删除 str[3]~str[n-1], 返回str
str.erase(2, 3);//删除 str[2]~str[2+3-1]
str.erase(str.begin());//删除指向的元素, 返回迭代器, 指向下一元素
str.erase(str.begin(), str.end());//删除区间内的元素, 返回迭代器, 指向下一元素

更改数据

replace (替换函数)

返回 str

str.replace(2,3,4,'s');//将 str[2]~str[2+3-1] 替换成 4 个 ‘s’
str.replace(2,3,ch);//将 str[2]~str[2+3-1] 替换成 ch
str.replace(2,3,ch,4);//将 str[2]~str[2+3-1] 替换成 ch的前 4 个字符
str.replace(2,3,ch,4,5);//将 str[2]~str[2+3-1] 替换成 ch[4]~ch[4+5-1]
str.replace(2,3,str1);//将 str[2]~str[2+3-1] 替换成 str1
str.replace(2,3,str1,4);//将 str[2]~str[2+3-1] 替换成 str1[4]~str1[n-1]
str.replace(2,3,str1,4,5);//将 str[2]~str[2+3-1] 替换成 str1[4]~str1[4+5-1]
str.replace(str.begin(),str.end(),3,'s');//将区间内的元素替换成 3 个 ‘s’
str.replace(str.begin(),str.end(),ch);//将区间内的元素替换成 ch
str.replace(str.begin(),str.end(),ch,3);//将区间内的元素替换成 ch 的前 3 个字符
str.replace(str.begin(),str.end(),str1);//将区间内的元素替换成 str1

copy (复制函数)

str.copy(ch, 3);//将 ch 前 3 个字符替换成 str 的前 3 个字符
str.copy(ch, 3, 2);//将 ch 前 3 个字符替换成 str[2]~str[2+3-1]

注: 更改的是 ch 数组

大小写转换

transform(str.begin(), str.end(), str1.begin(), ::toupper);
//将 str 的英文全部转换为大写, 赋值给 str1, str1.size() 必须大于等于 str.size()
transform(str.begin(), str.end(), str1.begin(), ::tolower);
//将 str 的英文全部转换为小写, 赋值给 str1

查找数据

find系列 (查找函数)

能找到返回下标，否则返回str.npos
包括:
find / rfind
find_first_of / find_first_not_of
find_last_of / find_last_not_of
其他五个函数的参数用法参考 find 函数

str.find('s');//返回字符 ‘s’ 在 str 中首次出现的位置
str.find('s', 2);//返回字符 ‘s’ 在 str[2]~str[n-1] 中首次出现的位置
str.find(ch);//返回字符串 ch 在 str 中首次出现的位置
str.find(ch, 4);//返回 ch 在 str[4]~str[n-1] 中首次出现的位置
str.find(ch, 4, 3);//返回 ch[0]~ch[3-1] 在 str[4]~str[n-1] 中首次出现的位置
str.find(str1);//返回 str1 在 str 中首次出现的位置
str.find(str1, 2);//返回 str1 在 str[2]~str[n-1] 中首次出现的位置
str.rfind(str1);//反向查找 str1 在 str 中首次出现的位置
str.rfind(str1,2);//反向查找 str1 在 str[0]~str[2+str1.size()-1] 中首次出现的位置
str.find_first_of(str1);//返回 str1 中任意一个字符在 str 中首次出现的位置
str.find_first_not_of(str1);//返回除 str1 以外的任意一个字符在 str 中首次出现的位置
str.find_last_of(str1);//返回 str1 中任意一个字符在 str 中最后一次出现的位置
str.find_last_not_of(str1);//返回除 str1 以外的任意一个字符在 str 最后一次出现的位置

substr (子串查找)

str.substr(2);//返回 str[2]~str[n-1], 不对 str 进行操作
str.substr(2,3);//返回 str[2]~str[2+3-1]

vector: 动态单向数组

简介

头文件：# include < vector >
动态单向数组, 只能在末端直接增删元素, 是最常用的一个容器.

构造函数

vector <int> v, v1;//定义 int 类型的数组
vector <char> vch;//定义 char 类型的数组
vector <string> vstr;//定义 string 类型的数组
vector <vector<int> > vv;//定义 int 类型的二维数组, 注意 '>' 之间的空格
vector <int> v2(10);//定义拥有 10 个元素的数组, 每个元素默认为 0
vector <int> v3(5, 30);//定义拥有 5 个元素的数组，并全部初始化为 30
vector <int> v4{ 1,2,3,4 };//定义拥有 4 个元素的数组, 初始化为{1,2,3,4}
vector <int> v5 = { 1,2,3,4 };//同上
vector <int> v6(v);//定义新容器, 拷贝 v 所有的元素
vector <int> v7 = v;//同上
vector <int> v8(v.begin(), v.begin() + 3);//定义新容器, 拷贝 v 区间内所有的元素

访问 / 赋值

迭代器

包括: begin、end、rbegin、end、cbegin、cend、crbegin、crend

下标 / at

支持下标 [] 和 at 函数随机访问容器内元素
v[id]; 返回下标为 id 的元素, 不检查是否越界
v.at(id); 返回下标为 id 的元素, 如果越界抛出异常

assign (赋值函数)

v.assign(2, 3);//将 2 个 3 赋值给 v
v.assign(v1.begin(), v1.end());//将区间内的元素赋值给 v

swap (交换函数)

v.swap(v1);//交换两个容器的内容

常用函数

v.push_back(4);//在末尾添加元素 4
v.pop_back();//删除最后一个元素
v.front();//返回第一元素
v.back();//返回最末元素
v.clear();//清空容器
v.empty();//容器为空返回true, 否则返回 false

长度 / 空间 / 容量相关函数

v.size();//返回容器内目前的元素个数
v.max_size();//返回元素个数 size 的最大值
v.resize(3);//设置 v 的 size，影响 size 和 capacity
//设置之后 capacity >= size=3，如果尺寸变小，多余的部分截掉
v.resize(3, 2);//设置 v 的 size，如果尺寸变大，新空间全部用 2 代替
v.capacity();//返回重新分配内存前 v 可以容纳的字符数，至少比size大
v.reserve(4);//设置 v 的 capacity=4，只影响 capacity. 设置之后，capacity=4

添加元素

insert (插入函数)

v.insert(v.begin(), 3);//在位置之前插入元素 3
v.insert(v.begin(), 2, 3);//在位置之前插入 2 个元素 3
v.insert(v.begin(), v1.begin(), v1.end());//在位置之前插入 v1 区间内所有的元素

emplace系列 (插入函数)

v.emplace(v.begin(), 3);//在位置之前插入元素 3, 相当于v.insert(v.begin(),3);
v.emplace_back(3);//在末端插入元素 3, 相当于v.push_back(3);

emplace / push_back / insert的区别

1. 原理上
   emplace是直接将在位置上构造插入的内容, 不需要生成对象
   push_back / insert是先生成具有复制内容的对象, 然后将对象的内容复制到容器里面
2. 功能上
   emplace / push_back只能插入一个元素
   insert可以插入多个
3. 性能上
   因为功能比较少, 所以emplace的速度要更快一点

push_back与insert的区别

1. 功能上
   push_back只能在末端添加元素
   insert可以在任何地方添加元素
2. 性能上
   push_back速度更快一点
   其实emplace系列还有一个函数 : emplace_front, 功能是在容器开头插入新的元素, 但是因为vector是单向数组, 因此vector里面并没有这个函数.

删除元素

erase (删除函数)

v.erase(v.begin());//删除位置上的元素, 返回迭代器, 指向下一个元素
v.erase(v.begin(), v.end());//删除区间内的元素

deque: 动态双向数组

简介

头文件: # include < deque >
动态双向数组, 与vector用法一样
区别
vector只能在末端直接进行增删操作, deque两端都可以

构造函数

deque<int> dv,dv1;

常用函数

dv.push_front(3);//在头部插入元素 3
dv.push_back(3);//在末端插入元素 3
dv.pop_front();//删除第一元素
dv.pop_back();//删除最末元素
dv.front();//返回第一元素
dv.back();//返回最末元素
dv.clear();//清空容器
dv.empty();//容器为空返回true, 否则返回 false

添加元素

emplace系列 (插入函数)

返回指向新元素位置的迭代器

dv.emplace(dv.begin(), 3);//在位置之前插入元素 3, 相当于dv.insert(dv.begin(),3);
dv.emplace_front(3);//在头部插入元素 3, 相当于dv.push_front(3);
dv.emplace_back(3);//在末端插入元素 3, 相当于dv.push_back(3);

list: 双向链表

简介

头文件: # include < list >
动态双向链表,用法和vector等容器基本相同, 但是内部结构区别很大

构造函数

list <int> l, l1;//定义 int 类型的链表
list <char> lch;//定义 char 类型的链表
list <string> lstr;//定义 string 类型的链表
list <int> l2(10);//定义拥有 10 个元素的链表, 每个元素默认为 0
list <int> l3(5, 30);//定义拥有 5 个元素的链表，并全部初始化为 30
list <int> l4{ 1,2,3,4 };//赋值
list <int> l5 = { 1,2,3,4 };//同上
list <int> l6(l);//定义新容器, 拷贝 l 所有的元素
list <int> l7(l.begin(), l.end());//定义新容器, 拷贝 l 区间内所有的元素

访问/赋值

迭代器

分为：begin、end、rbegin、rend、cbegin、cend、crbegin、crend

下标 / at

不支持下标 [] 和 at 函数随机访问容器内元素,只能通过迭代器访问

assign (赋值函数)

l.assign(3, 4);//将 3 个 4 赋值给 l
l.assign(l1.begin(), l1.end());//将区间内的元素赋值给 l

swap (交换函数)

l.swap(l1);//交换两个容器的内容

常用函数

l.push_front(3);//在头部插入元素 3
l.push_back(3);//在末端插入元素 3
l.pop_front();//删除第一元素
l.pop_back();//删除最末元素
l.front();//返回第一元素
l.back();//返回最末元素
l.clear();//清空容器
l.empty();//容器为空返回 true, 否则返回 false

长度 / 空间 / 容量相关函数

l.size();//返回容器目前的元素个数
l.max_size();//返回元素个数 size 的最大值
l.resize(3);//设置 l 的 size，影响 size，设置之后 size=3，如果尺寸变小，多余的部分截掉, 
l.resize(3, 2);//设置 l 的 size，如果尺寸变大，新空间全部用 2 代替

添加元素

insert (插入函数)

l.insert(l.begin(), 3);//在位置之前插入元素 3
l.insert(l.begin(), 2, 3);//在位置之前插入 2 个元素 3
l.insert(l.begin(), l1.begin(), l1.end());//在位置之前插入l1 区间内所有的元素

emplace系列 (插入函数)

l.emplace(l.begin(), 3);//在位置之前插入元素 3, 相当于l.insert(l.begin(),3);
l.emplace_front(3);//在头部插入元素 3, 相当于l.push_front(3);
l.emplace_back(3);//在末端插入元素 3, 相当于l.push_back(3);

merge (合并函数)

l.merge(l1);//将 l1 的全部元素转移到 l 
//保证转移之前的 l/l1 有序, 转移后的 l 同样有序, 默认升序
例: l={1,3,5}, l1={2,4,6}
执行之后, l={1,2,3,4,5,6}, l1={};
l.merge(l1, greater <int>());//将 l1 的全部元素转移到 l, 排序准则为降序
l.merge(l1, op);// 将 l1 的全部元素转移到 l, 排序准则为 op

splice (拼接函数)

l.splice(l.begin(), l1);//将 l1 转移到 l 的位置之前
l.splice(l.begin(), l1, l1.begin());//将 l1 所指元素转移到 l 的位置之前
例: l={1,3,5}, l1={2,4,6}
执行之后, l={2,1,3,5}, l1={4,6};
l.splice(l.begin(), l1, l1.begin(), l1.end());//将 l1 区间内元素转移到 l 的位置之前

删除元素

erase (删除函数)

l.erase(l.begin());//删除位置上的元素, 返回迭代器, 指向下一个元素
l.erase(l.begin(), l.end());//删除区间内的元素
remove系列 (移除函数)
l.remove(3);//删除所有值为 3 的元素
l.remove_if(op);//删除使 op() 为true的元素
bool op(int a) {// 10~100 返回 false, 其余返回 true(删除不在10~100内的数)
	return a < 10 || a>100;
}

unique (排重函数)

l.unique();//删除相邻的相同元素, 只留一个

更改数据

reverse (翻转函数)

l.reverse();//翻转容器

sort (排序函数)

l.sort();//升序排序
l.sort(greater<int>());//降序排序
l.sort(op);//以 op 为准则, 将所有元素排序

forward_list: 单向链表

简介

头文件: # include < forward_list >
动态单向链表, 将 list 末端封住, 只对成员函数来说, forward_list更像一个链表

构造函数

forward_list <int> fl, fl1;//定义 int 类型的链表
forward_list <char> flch;//定义 char 类型的链表
forward_list <string> flstr;//定义 string 类型的链表
forward_list <int> fl2(10);//定义拥有 10 个元素的链表, 每个元素默认为 0
forward_list <int> fl3(5, 30);//定义拥有 5 个元素的链表，并全部初始化为 30
forward_list <int> fl4{ 1,2,3,4 };//赋值
forward_list <int> fl5 = { 1,2,3,4 };//同上
forward_list <int> fl6(fl);//定义新容器, 拷贝 fl 所有的元素
forward_list <int> fl7(fl.begin(), fl.end());//定义新容器, 拷贝 l 区间内所有的元素

访问 / 赋值

迭代器

分为：begin、end、cbegin、cend、before_begin、cbefore_begin

下标 / at

不支持下标 [] 和 at 函数随机访问容器内元素,只能通过迭代器访问

assign (赋值函数)

fl.assign(3, 4);//将 3 个 4 赋值给 fl
fl.assign(fl1.begin(), fl1.end());//将区间内的元素赋值给 fl

swap (交换函数)

fl.swap(fl1);//交换两个容器的内容

常用函数

fl.push_front(3);//在头部插入元素 3
fl.pop_front();//删除第一元素
fl.front();//返回第一元素
fl.clear();//清空容器
fl.empty();//容器为空返回 true, 否则返回 false

长度 / 空间 / 容量相关函数

fl.max_size();//返回 fl 元素个数的最大值
fl.resize(3);//设置 fl 的 size，如果尺寸变小，多余的部分截掉, 尺寸变大, 新空间用 0 代替
fl.resize(3, 2);//设置 fl 的 size，如果尺寸变大，新空间全部用 2 代替

添加元素

insert_after (插入函数)

fl.insert_after(fl.begin(), 3);//在位置之后插入元素 3
fl.insert_after(fl.begin(), 2, 3);//在位置之后插入 2 个元素 3
fl.insert_after(fl.begin(), fl1.begin(), fl1.end());
//在 fl 位置之后插入 fl1 区间的元素

emplace (插入函数)

fl.emplace_front();//在容器的头部插入一个元素, 默认为 0
fl.emplace_front(5);//在容器的头部插入一个元素 5
fl.emplace_after(fl.begin(), 5);//在位置之后插入元素 5

merge (合并函数)

fl.merge(fl1); //将 fl1 的全部元素转移到 fl 
//保证转移之前的 fl/fl1 有序, 转移后的 fl 同样有序, 默认升序
fl.merge(fl1, greater <int>());//将 fl1 的全部元素转移到 fl, 排序准则为降序
fl.merge(fl1, op); // 将 fl1 的全部元素转移到 fl, 排序准则为 op

splice_after (拼接函数)

fl.splice_after(fl.begin(), fl1);// 将 fl1 转移到 fl 的位置之后
fl.splice_after(fl.begin(), fl1, fl1.begin());//将 fl1 所指元素转移到 fl 的位置之后
fl.splice_after(fl.begin(), fl1, fl1.begin(),fl1.end());
//将 fl1 区间内元素转移到 fl 的位置之后

删除元素

erase_after (删除函数)

fl.erase_after(fl.begin());//删除指向位置之后的元素
fl.erase_after(fl.begin(), fl.end());//删除区间内的元素(保留区间内的第一个元素)

remove系列 (移除函数)

fl.remove(3);// 删除所有值为 3 的元素
fl.remove_if([](int a) { return a > 3; });//删除大于 3 的元素
fl.remove_if(op);// 删除使 op 为true的元素

unique (排重函数)

fl.unique();//删除相邻的相同元素, 只留一个

更改数据

reverse (翻转函数)

fl.reverse();//翻转容器

sort (排序函数)

fl.sort();//升序排序
fl.sort(greater<int>());//降序排序
fl.sort(op); //以 op 为准则, 将所有元素排序

pair: 组合容器

简介

头文件: # include < utility >
pair是将两个元素组合成一个整体的容器
相当于 map 容器的一个元素, 也相当于一个拥有两个元素的结构体

构造函数

pair <int, int> p, p1;//定义 [int,int] 型容器
pair <int, char> pich;//定义 [int,char] 型容器
pair <int, string> pistr;//定义 [int,string] 型容器
pair <string, int> pstri;//定义 [string,int] 型容器
pair <int, int> p2(p); //定义新容器, 拷贝 p 所有的元素
pair <int, int> p3(1, 2);//赋值
pair <int, int> p4{ 1,2 };//同上
pair <int, int> p5 = { 1,2 };//同上

访问 / 赋值

下标 / at

因为只有一个元素, 所以不支持下标 [] 和 at 函数随机访问

swap (交换函数)

p.swap(p1);//交换两个容器的内容

常用函数

p.first;//返回 p 的第一个内容
p.second;//返回 p 的第二个内容

set / multiset: 有序集合关联容器

简介

头文件: # include < set >
会根据特定的排序标准，自动将元素进行排序。容器内的元素一直有序. 默认使用升序排序.
set和multiset的区别
set: 容器中一种元素只能存在一个
multiset: 容器中一种元素可以存在多个
其他用法都相同.

构造函数

set <int> s, s1;//定义 int 类型的set容器
multiset <int> ms, ms1;//定义 int 类型的multiset容器
set <char> sch;//定义 char 类型的容器
set <string> sstr;//定义 string 类型的容器
set <int> s3{ 1,2,3,4 };//赋值
set <int> s4 = { 1,2,3,4 };//同上
set <int> s5(s);//定义新容器, 拷贝 s 所有的元素
set <int> s6(s.begin(), s.end());//定义新容器, 拷贝 s 区间内所有的元素
set <int, greater<int> > s7;//排序准则为降序
set <int, op > s8; //排序准则为 op

访问 / 赋值

迭代器

分为：begin、end、rbegin、rend、cbegin、cend、crbegin、crend

下标 / at

不支持下标 [] 和 at 函数随机访问容器内元素,只能通过迭代器访问

swap (交换函数)

s.swap(s1);//交换两个容器的内容

常用函数

s.clear();//清空容器
s.empty();//容器为空返回 true, 否则返回 false

长度 / 空间 / 容量相关函数

s.size();//返回容器目前的元素个数
s.max_size();//返回元素个数 size 的最大值

添加元素

insert (插入函数)

s.insert(3);//插入元素 3, set:如果重复, 此语句不执行
s.insert(s.begin(), 3);//在位置之前插入元素 3, 用的不多, 指定位置之后还要排序
s.insert(s1.begin(), s1.end());//插入 s1 区间所有的元素

emplace系列 (插入函数)

s.emplace(3);//插入元素 3
s.emplace_hint(s.begin(), 3);//在位置上插入元素 3, 指定位置之后还要排序

删除元素

erase (删除函数)

s.erase(3);//删除值为 3 的元素
s.erase(s.begin());//删除指向的元素
s.erase(s.begin(), s.end());//删除区间内的所有元素

查找数据

容器内部元素有序, 因此查找时采用二分.

s.count(3);//返回元素值为 3 的元素个数
s.find(3);//返回迭代器, 指向元素值为 3 的第一个元素, 如果没有就返回 end()
s.lower_bound(3);//返回迭代器, 指向 元素值>=3 的第一个元素的位置
s.upper_bound(3);//返回迭代器, 指向 元素值>3 的第一个元素的位置
s.equal_range(3);//返回 pair 容器: [s.lower_bound(3), s.upper_bound(3)]

map / multimap: 有序键值对关联容器

简介

头文件: # include < map >
容器的每个元素类型为 pair, 将 pair 的第一部分作为 键(key), 第二部分作为 值(value), key 具有容器set的特点: 有序性, 每个 key 都有一个 value 对应, 而 value没有什么限制
会根据特定的排序标准，自动将元素进行排序。容器内的元素一直是有序的. 默认使用升序排序.

map和multimap的区别
map: 容器中 key 只能存在一个, 支持随机访问
multimap: 容器 key 可以存在多个, 不支持随机访问
其他用法都相同.

构造函数

map <int, string> m, m1;//定义 [int,string] 类型的map容器
multimap <int, string> mm, mm1;//定义 [int,string] 类型的multimap容器
map <char, int> mchi;//定义 [char,int] 类型的容器
map <string, int> mstri;//定义 [string,int] 类型的容器
map <int, string> m3{ {1,"aaa"}, {2,"bbb"},{3,"ccc"} };//赋值
map <int, string> m4 = { {1,"aaa"}, {2,"bbb"},{3,"ccc"} };//同上
map <int, string> m5(m);//定义新容器, 拷贝 m 所有的元素
map <int, string> m6(m.begin(), m.end());//定义新容器, 拷贝 m 区间内所有的元素
map <int, string, greater<int> > m7;//排序准则为降序
map <int, string, op > m8; //排序准则为 op

访问 / 赋值

迭代器

分为：begin、end、rbegin、rend、cbegin、cend、crbegin、crend

下标 / at

可以使用下标 [] 和 at 函数随机访问, 并不一定是数字, 这种方式只适合map
例: m = { {1,“aaa”}, {2,“bbb”},{3,“ccc”} };
则: m[2]=m.at(2)=”bbb”
例: mstri = { { “aaa”,1 }, { “bbb”,a }, { “ccc”,3 } };
则: mstri[“bbb”]=mstri.at(“bbb”)=2;

swap (交换函数)

m.swap(m1);//交换两个容器的内容

常用函数

m.clear();//清空容器
m.empty();//容器为空返回 true, 否则返回 false

长度 / 空间 / 容量相关函数

m.size();//返回容器目前的元素个数
m.max_size();//返回元素个数 size 的最大值

添加元素

insert (插入函数)

m.insert({ 4,"ddd" });//插入元素 {4,"ddd"}, map: 如果重复, 此语句不执行
m.insert(m.begin(), { 4,"ddd" });
//在位置之后插入元素 {4,"ddd"}, 用的不多, 指定位置之后还要排序
m.insert(m1.begin(), m1.end());//插入 m1 区间所有的元素

emplace系列 (插入函数)

m.emplace(pair <int, string> {4, "ddd"});//插入元素 {4,"ddd"}
m.emplace_hint(m.begin(), pair <int, string>{4, "ddd"});
//在位置之后插入元素 {4,"ddd"}, 用的不多, 指定位置之后还要排序

删除元素

erase (删除函数)

m.erase(3);//删除 key 为 3 的元素
m.erase(m.begin());//删除指向的元素
m.erase(m.begin(), m.end());//删除区间内所有的元素

更改数据

可以使用 key 随机访问并更改 value
例: m[“aaa”]=3; 或者 m.at(“aaa”)=3;

查找数据

容器内部元素有序, 因此查找时采用2分.

m.count(3);//返回 key 为 3 的元素个数
m.find(3);//返回迭代器, 指向 key 值为 3 的第一个元素, 如果没有就返回 end()
m.lower_bound(3);//返回迭代器, 指向 key 值>=3 的第一个元素的位置
m.upper_bound(3);//返回迭代器, 指向 key 值>3 的第一个元素的位置
m.equal_range(3);//返回 pair 容器: [m.lower_bound(3), m.upper_bound(3)]

unordered_x: 无序关联容器

简介

无序关联容器包括:

unordered_set <int> us;				//头文件: # include 
unordered_multiset <int> ums;		//头文件: # include 
unordered_map <int, int> um;			//头文件: # include 
unordered_multimap <int, int> umm;	//头文件: # include 

有序关联容器包括:

set <int> s;					//头文件: # include 
multiset <int> ms;			//头文件: # include 
map <int, int> m;			//头文件: # include 
multimap <int, int>mm;		//头文件: # include 

区别总结

set: 容器内元素是有序的, 元素不能重复
multiset: 容器内元素是有序的, 元素可以重复
unordered_set: 容器内元素是无序的, 元素不能重复
unordered_multiset: 容器内元素是无序的, 元素可以重复
map: 容器元素是 键值对(pair), 元素按照 key 排序, key不能重复, 支持随机访问
multimap: 容器内元素按照 key 排序, key 可以重复
unordered_map: 容器内 key 是无序的, key 不能重复, 支持随机访问
unordered_multimap: 容器内 key 是无序的, key可以重复

其他

无序关联容器的顺序是随机的

bucket接口

unordered_x系列容器提供bucket接口, 提供很多相关的函数

stack: 栈

简介

头文件: # include < stack >
模拟栈的功能和特点: 元素后进先出, 只能访问栈顶元素, 属于C++特殊容器

构造函数

stack <int> st, st1;//定义 int 类型的栈
stack <char> stch;//定义 char 类型的栈
stack <string> ststr;//定义 string 类型的栈
stack <int> st2(st);// 定义新容器, 拷贝 st 所有的元素
stack <int, vector<int> > st3;//底层使用 vector 容器实现栈, 默认是 deque	

成员函数

st.top();//返回栈顶元素
st.push(5);//在栈顶插入新元素 5
st.emplace(5);//在栈顶创建新元素 5
st.pop();//删除栈顶元素
st.size();//返回容器目前的元素个数
st.empty();//容器为空返回 true, 否则返回 false
st.swap(st1);//交换两个容器的内容

queue: 队列

简介

头文件: # include < queue >
模拟队列的功能和特点: 元素先进先出, 可以访问队列两端元素, 属于C++特殊容器

构造函数

queue <int> q, q1;//定义 int 类型的队列
queue <char> qch;//定义 char 类型的队列
queue <string> qstr;//定义 string 类型的队列
queue <int> q2(q);//定义新容器, 拷贝 q 所有的元素
queue <int, vector<int> > q3;//使用 vector 容器实现队列, 默认是 deque

成员函数

q.front();//返回队列头部元素
q.back();//返回队列尾部元素
q.push(5);//在队列尾部插入新元素 5
q.emplace(5);//在队列尾部创建新元素 5
q.pop();//删除队列头部元素
q.size();//返回容器目前的元素个数
q.empty();//容器为空返回 true, 否则返回 false
q.swap(q1);//交换两个容器的内容

priority_queue: 优先队列

简介

头文件: # include < queue >
在队列的基础上将内部进行排序, 默认降序, 只能访问头部

构造函数

priority_queue <int> pq, pq1;//定义 int 类型的优先队列
priority_queue <char> pqch;//定义 char 类型的优先队列
priority_queue <string> pqstr;//定义 string 类型的优先队列
priority_queue <int> pq2(pq);//定义新容器, 拷贝 pq 所有的元素
priority_queue <int, vector<int> > pq3;//使用 vector 容器实现优先队列
priority_queue <int, vector <int>, greater <int> > pq2;//升序排列容器内元素.

成员函数

pq.top();//返回队列头部元素
pq.push(5);//在队列尾部插入新元素 5
pq.emplace(5);//在队列尾部创建新元素 5
pq.pop();//删除队列头部元素
pq.size();//返回容器目前的元素个数
pq.empty();//容器为空返回true, 否则返回 false
pq.swap(pq1);//交换两个容器的内容