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++ 常用容器成员函数用法总结》对你有帮助，请点赞、收藏，并留下你的观点哦！