C++ 常用容器成员函数用法总结
C++ 常用容器成员函数用法总结简介迭代器简介 array: 静态数组简介构造函数访问 / 赋值迭代器下标 / at批量赋值swap (交换函数) 常用函数长度/空间/容量相关函数 string:字符串简介构造函数访问 / 赋值迭代器下标 / atassign (赋值函数)连接符swap (交换函数) 常用函数长度 / 空间 / 容量相关函数添加元素insert (插入函数)append (连接函数) 删除元素erase (删除函数) 更改数据replace (替换函数)copy (复制函数)大小写转换 查找数据find系列 (查找函数)substr (子串查找) vector: 动态单向数组简介构造函数访问 / 赋值迭代器下标 / atassign (赋值函数)swap (交换函数) 常用函数长度 / 空间 / 容量相关函数添加元素insert (插入函数)emplace系列 (插入函数) 删除元素erase (删除函数) deque: 动态双向数组简介构造函数常用函数添加元素emplace系列 (插入函数) list: 双向链表简介构造函数访问/赋值迭代器下标 / atassign (赋值函数)swap (交换函数) 常用函数长度 / 空间 / 容量相关函数添加元素insert (插入函数)emplace系列 (插入函数)merge (合并函数)splice (拼接函数) 删除元素erase (删除函数)unique (排重函数) 更改数据reverse (翻转函数)sort (排序函数) forward_list: 单向链表简介构造函数访问 / 赋值迭代器下标 / atassign (赋值函数)swap (交换函数) 常用函数长度 / 空间 / 容量相关函数添加元素insert_after (插入函数)emplace (插入函数)merge (合并函数)splice_after (拼接函数) 删除元素erase_after (删除函数)remove系列 (移除函数)unique (排重函数) 更改数据reverse (翻转函数)sort (排序函数) pair: 组合容器简介构造函数访问 / 赋值下标 / atswap (交换函数) 常用函数 set / multiset: 有序集合关联容器简介构造函数访问 / 赋值迭代器下标 / atswap (交换函数) 常用函数长度 / 空间 / 容量相关函数添加元素insert (插入函数)emplace系列 (插入函数) 删除元素erase (删除函数) 查找数据 map / multimap: 有序键值对关联容器简介构造函数访问 / 赋值迭代器下标 / atswap (交换函数) 常用函数长度 / 空间 / 容量相关函数添加元素insert (插入函数)emplace系列 (插入函数) 删除元素erase (删除函数) 更改数据查找数据 unordered_x: 无序关联容器简介区别总结其他bucket接口 stack: 栈简介构造函数成员函数 queue: 队列简介构造函数成员函数 priority_queue: 优先队列简介构造函数成员函数简介
包括以下容器
array <int, 10> a; ~~~~~~~~~~~~~~~~~//# include <array>string str; ~~~~~~~~~~~~~~~~~~~~~~~~//# include <string>vector <int> v; ~~~~~~~~~~~~~~~~~~~~//# include <vector>deque <int> dv; ~~~~~~~~~~~~~~~~~~~~//# include <deque>list <int> l; ~~~~~~~~~~~~~~~~~~~~~~//# include <list>forward_list <int> fl; ~~~~~~~~~~~~~//# include <forward_list>pair <int, int> p; ~~~~~~~~~~~~~~~~~//# include <utility>set <int> s; ~~~~~~~~~~~~~~~~~~~~~~~//# include <set>multiset <int> ms;~~~~~~~~~~~~~~~~~~//# include <set>map <int, int> m;~~~~~~~~~~~~~~~~~~~//# include <map>multimap <int, int>mm;~~~~~~~~~~~~~~//# include <map>unordered_set <int> us;~~~~~~~~~~~~~//# include <unorder_set>unordered_multiset <int> ums;~~~~~~~//# include <unorder_set>unordered_map <int, int> um;~~~~~~~~//# include <unorder_map>unordered_multimap <int, int> umm;~~//# include <unorder_map>stack <int> st; ~~~~~~~~~~~~~~~~~~~~//# include <stack>queue <int> q; ~~~~~~~~~~~~~~~~~~~~~//# include <queue>priority_queue <int> pq;~~~~~~~~~~~~//# include <queue>
点击前往: 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);//将容器的每个元素都赋值成 3a.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’ 赋值给 strstr.assign(str1);//将 str1 赋值给 strstr.assign(str1, 2);//将 str1[2]~str1[n-1] 赋值给 strstr.assign(str1, 2, 3);//将 str1[2]~str1[2+3-1] 赋值给 strstr.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-1str.reserve(3);//设置 str 的 capacity,以保留 3 个字符空间,只影响 capacity。//设置之后,capacity>=3
添加元素
insert (插入函数)
str.insert(2, 3, 's');//在位置之前插入 3 个字符 ‘s’str.insert(2, "string");//在位置之前插入字符串 “string”, 返回strstr.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 末尾添加 str1str.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], 返回strstr.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] 替换成 chstr.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] 替换成 str1str.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);//将区间内的元素替换成 chstr.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 个元素的数组, 每个元素默认为 0vector <int> v3(5, 30);//定义拥有 5 个元素的数组,并全部初始化为 30vector <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 赋值给 vv.assign(v1.begin(), v1.end());//将区间内的元素赋值给 v
swap (交换函数)
v.swap(v1);//交换两个容器的内容
常用函数
v.push_back(4);//在末尾添加元素 4v.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);//在位置之前插入元素 3v.insert(v.begin(), 2, 3);//在位置之前插入 2 个元素 3v.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的区别
原理上
emplace是直接将在位置上构造插入的内容, 不需要生成对象
push_back / insert是先生成具有复制内容的对象, 然后将对象的内容复制到容器里面功能上
emplace / push_back只能插入一个元素
insert可以插入多个性能上
因为功能比较少, 所以emplace的速度要更快一点
push_back与insert的区别
功能上
push_back只能在末端添加元素
insert可以在任何地方添加元素性能上
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);//在头部插入元素 3dv.push_back(3);//在末端插入元素 3dv.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 个元素的链表, 每个元素默认为 0list <int> l3(5, 30);//定义拥有 5 个元素的链表,并全部初始化为 30list <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 赋值给 ll.assign(l1.begin(), l1.end());//将区间内的元素赋值给 l
swap (交换函数)
l.swap(l1);//交换两个容器的内容
常用函数
l.push_front(3);//在头部插入元素 3l.push_back(3);//在末端插入元素 3l.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);//在位置之前插入元素 3l.insert(l.begin(), 2, 3);//在位置之前插入 2 个元素 3l.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 个元素的链表, 每个元素默认为 0forward_list <int> fl3(5, 30);//定义拥有 5 个元素的链表,并全部初始化为 30forward_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 赋值给 flfl.assign(fl1.begin(), fl1.end());//将区间内的元素赋值给 fl
swap (交换函数)
fl.swap(fl1);//交换两个容器的内容
常用函数
fl.push_front(3);//在头部插入元素 3fl.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);//在位置之后插入元素 3fl.insert_after(fl.begin(), 2, 3);//在位置之后插入 2 个元素 3fl.insert_after(fl.begin(), fl1.begin(), fl1.end());//在 fl 位置之后插入 fl1 区间的元素
emplace (插入函数)
fl.emplace_front();//在容器的头部插入一个元素, 默认为 0fl.emplace_front(5);//在容器的头部插入一个元素 5fl.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);//插入元素 3s.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 <unorder_set>unordered_multiset <int> ums;//头文件: # include <unorder_set>unordered_map <int, int> um;//头文件: # include <unorder_map>unordered_multimap <int, int> umm;//头文件: # include <unorder_map>
有序关联容器包括:
set <int> s;//头文件: # include <set>multiset <int> ms;//头文件: # include <set>map <int, int> m;//头文件: # include <map>multimap <int, int>mm;//头文件: # include <map>
区别总结
set: 容器内元素是有序的, 元素不能重复
multiset: 容器内元素是有序的, 元素可以重复
unordered_set: 容器内元素是无序的, 元素不能重复
unordered_multiset: 容器内元素是无序的, 元素可以重复
map: 容器元素是 键值对(pair<key,value>), 元素按照 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);//在栈顶插入新元素 5st.emplace(5);//在栈顶创建新元素 5st.pop();//删除栈顶元素st.size();//返回容器目前的元素个数st.empty();//容器为空返回 true, 否则返回 falsest.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);//在队列尾部插入新元素 5q.emplace(5);//在队列尾部创建新元素 5q.pop();//删除队列头部元素q.size();//返回容器目前的元素个数q.empty();//容器为空返回 true, 否则返回 falseq.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);//在队列尾部插入新元素 5pq.emplace(5);//在队列尾部创建新元素 5pq.pop();//删除队列头部元素pq.size();//返回容器目前的元素个数pq.empty();//容器为空返回true, 否则返回 falsepq.swap(pq1);//交换两个容器的内容
如果觉得《C++ 常用容器成员函数用法总结》对你有帮助,请点赞、收藏,并留下你的观点哦!