这是我引用转载“亦已歌”的文章，主要是在开发的过程中学习；
在此转载主要是为了后期能更方便的找到该博主的文章；
如有侵权，请联系我，我既可删除。
该篇文章在转载时，代码部分有乱码，如需参考，请移步至原文处；
原文链接：https://blog.csdn.net/m0_73216388/article/details/136782568
在C++的标准模板库（STL）中，不同的容器有各自独特的属性和用途。以下是一些常见STL容器的比较：
顺序容器:
vector: 动态数组，提供快速随机访问。适合于元素数量经常变化的情况。deque: 双端队列，与vector类似，但在前端插入和删除操作更高效。list: 双向链表，支持快速插入和删除，但不支持随机访问。forward_list: 单向链表，与list类似，但仅支持单向顺序访问。array: 固定大小数组，支持快速随机访问，但大小在编译时固定。
关联容器:
set: 基于红黑树的集合，元素唯一且自动排序。multiset: 类似set，但允许重复元素。map: 基于红黑树的键值对集合，每个键唯一。multimap: 类似map，但允许键有重复。
无序关联容器:
unordered_set: 基于哈希表的集合，元素唯一，不自动排序。unordered_multiset: 类似unordered_set，但允许重复元素。unordered_map: 基于哈希表的键值对集合，每个键唯一。unordered_multimap: 类似unordered_map，但允许键有重复。
容器适配器:
stack: 后进先出（LIFO）的容器适配器。queue: 先进先出（FIFO）的容器适配器。priority_queue: 元素按优先级出队的容器适配器。
每种容器都有其特定的使用场景。例如，如果需要频繁在序列中间插入和删除元素，list 或 forward_list 可能是最佳选择。如果需要快速访问任意元素，vector 或 array 可能更合适。对于需要键值对存储且有唯一键的数据，map 是一个好的选择，而当数据中键可以重复时，可以使用multimap。无序关联容器通常在元素不需要排序且插入和查找操作非常频繁时使用。
下面是一些容器插入，删除，访问，大小操作方法概览：
vector（向量）:
- 插入:
push_back,insert - 删除:
pop_back,erase - 访问:
operator[],at,front,back - 大小:
size,empty,resize
deque（双端队列）:
- 插入:
push_back,push_front,insert - 删除:
pop_back,pop_front,erase - 访问:
operator[],at,front,back - 大小:
size,empty,resize
list（列表）:
- 插入:
push_back,push_front,insert - 删除:
pop_back,pop_front,erase - 访问:
front,back - 大小:
size,empty
map（映射）:
- 插入:
insert,emplace - 删除:
erase - 访问:
operator[],at,find - 大小:
size,empty
set（集合）:
- 插入:
insert,emplace - 删除:
erase - 访问:
find,count - 大小:
size,empty
queue（队列）:
- 插入:
push - 删除:
pop - 访问:
front,back - 大小:
size,empty
stack（栈）:
- 插入:
push - 删除:
pop - 访问:
top - 大小:
size,empty
unordered_set（无序集合）:
- 插入:
insert,emplace - 删除:
erase - 访问:
find,count - 大小:
size,empty
unordered_map（无序映射）:
- 插入:
insert,emplace - 删除:
erase - 访问:
operator[],at,find - 大小:
size,empty
以下是C++中各种容器的初始化、赋值、访问、插入、删除和修改元素方法的对照表：
vector（向量）
-
#include
<vector
>
-
/
/ 初始化
-
std
::vector
<int
> v
1;
/
/ 默认初始化
-
std
::vector
<int
> v
2
= {
1,
2,
3};
/
/ 列表初始化
-
std
::vector
<int
> v
3(v
2);
/
/ 拷贝初始化
-
std
::vector
<int
> v
4(
5,
10);
/
/ 初始化为
5个值为
10的元素
-
-
/
/ 赋值
-
v
1
= {
4,
5,
6};
/
/ 使用初始化列表赋值
-
v
1.
assign({
7,
8,
9});
/
/ 使用
assign和初始化列表赋值
-
-
/
/ 访问
-
int
value
= v
1[
0];
/
/ 通过索引访问
-
value
= v
1.
at(
1);
/
/ 通过
at方法访问，如果索引越界会抛出异常
-
int front
= v
1.front();
/
/ 访问第一个元素
-
int back
= v
1.back();
/
/ 访问最后一个元素
-
-
/
/ 插入
-
v
1.push_back(
10);
/
/ 在末尾插入元素
-
v
1.insert(v
1.begin(),
11);
/
/ 在指定位置插入元素
-
-
/
/ 删除
-
v
1.pop_back();
/
/ 删除最后一个元素
-
v
1.erase(v
1.begin());
/
/ 删除迭代器指定的元素
-
-
/
/ 修改
-
v
1[
0]
=
12;
/
/ 修改指定索引的元素
set（集合）
-
#include
<
set
>
-
/
/ 初始化
-
std
::
set
<int
> s
1;
/
/ 默认初始化
-
std
::
set
<int
> s
2
= {
1,
2,
3};
/
/ 列表初始化
-
std
::
set
<int
> s
3(s
2);
/
/ 拷贝初始化
-
-
/
/ 赋值
-
s
1
= {
4,
5,
6};
/
/ 使用初始化列表赋值
-
s
1.insert(
7);
/
/ 插入单个元素
-
-
/
/ 访问
-
auto it
= s
1.find(
4);
/
/ 查找元素
-
if (it !
= s
1.
end()) std
::cout
<
<
*it
<
< std
::endl;
/
/ 如果找到，访问元素
-
-
/
/ 插入
-
s
1.insert(
8);
/
/ 插入单个元素
-
s
1.insert({
9,
10});
/
/ 插入初始化列表
-
-
/
/ 删除
-
s
1.erase(
4);
/
/ 删除指定元素
-
s
1.erase(s
1.begin());
/
/ 删除迭代器指定的元素
-
-
/
/ 修改
-
/
/
set容器不支持直接修改元素，因为它会破坏集合的有序性。如果需要修改，必须先删除再插入。
map（映射）
-
#include
<map
>
-
/
/ 初始化
-
std
::map
<int, std
::
string
> m
1;
/
/ 默认初始化
-
std
::map
<int, std
::
string
> m
2
= {{
1,
"a"}, {
2,
"b"}};
/
/ 列表初始化
-
std
::map
<int, std
::
string
> m
3(m
2);
/
/ 拷贝初始化
-
std
::map
<int, std
::
string
> m
4(std
::make_pair(
1,
"a"));
/
/ 使用make_pair初始化
-
-
/
/ 赋值
-
m
1[
1]
=
"a";
/
/ 直接赋值
-
m
1.insert(std
::make_pair(
2,
"b"));
/
/ 插入pair
-
m
1.insert({{
3,
"c"}, {
4,
"d"}});
/
/ 插入初始化列表
-
-
/
/ 访问
-
std
::
string
value
= m
1[
1];
/
/ 通过键访问
-
auto it
= m
1.find(
2);
/
/ 查找元素
-
if (it !
= m
1.
end())
value
= it-
>second;
/
/ 通过迭代器访问
-
-
/
/ 插入
-
m
1[
5]
=
"e";
/
/ 插入新元素
-
m
1.insert(std
::make_pair(
6,
"f"));
/
/ 插入pair
-
-
/
/ 删除
-
m
1.erase(
1);
/
/ 通过键删除
-
m
1.erase(m
1.begin());
/
/ 通过迭代器删除
-
-
/
/ 修改
-
m
1[
1]
=
"new value";
/
/ 修改元素的值
list（列表）
-
#include
<list
>
-
/
/ 初始化
-
std
::list
<int
> l
1;
/
/ 默认初始化
-
std
::list
<int
> l
2
= {
1,
2,
3,
4};
/
/ 列表初始化
-
std
::list
<int
> l
3(l
2);
/
/ 拷贝初始化
-
-
/
/ 赋值
-
l
1
= {
5,
6,
7,
8};
/
/ 使用初始化列表赋值
-
l
1.
assign({
9,
10,
11,
12});
/
/ 使用
assign和初始化列表赋值
-
-
/
/ 访问
-
int front
= l
1.front();
/
/ 访问第一个元素
-
int back
= l
1.back();
/
/ 访问最后一个元素
-
-
/
/ 插入
-
l
1.push_front(
0);
/
/ 在前端插入元素
-
l
1.push_back(
13);
/
/ 在后端插入元素
-
auto it
= l
1.begin();
-
advance(it,
2);
-
l
1.insert(it,
14);
/
/ 在迭代器指定位置插入元素
-
-
/
/ 删除
-
l
1.pop_front();
/
/ 删除第一个元素
-
l
1.pop_back();
/
/ 删除最后一个元素
-
l
1.erase(l
1.begin());
/
/ 删除迭代器指定的元素
-
-
/
/ 修改
-
*it
=
15;
/
/ 修改迭代器指定元素的值
queue（队列）
-
#include
<queue
>
-
/
/ 初始化
-
std
::queue
<int
> q
1;
/
/ 默认初始化
-
std
::queue
<int
> q
2(std
::deque
<int
>{
1,
2,
3});
/
/ 使用deque初始化
-
-
/
/ 访问
-
int front
= q
1.front();
/
/ 访问第一个元素
-
int back
= q
1.back();
/
/ 访问最后一个元素
-
-
/
/ 插入
-
q
1.push(
4);
/
/ 在末尾插入元素
-
-
/
/ 删除
-
q
1.pop();
/
/ 删除第一个元素
-
-
/
/ 大小
-
size_t
size
= q
1.
size();
/
/ 获取队列中元素个数
-
bool empty
= q
1.empty();
/
/ 判断队列是否为空
-
-
/
/ 修改
-
/
/ queue不提供直接修改元素的方法，因为它遵循先进先出的原则。
deque（双端队列）
-
#include
<deque
>
-
/
/ 初始化
-
std
::deque
<int
> d
1;
/
/ 默认初始化
-
std
::deque
<int
> d
2
= {
1,
2,
3};
/
/ 列表初始化
-
std
::deque
<int
> d
3(
5,
10);
/
/ 初始化为
5个值为
10的元素
-
-
/
/ 赋值
-
d
1
= {
4,
5,
6};
/
/ 使用初始化列表赋值
-
d
1.
assign({
7,
8,
9});
/
/ 使用
assign和初始化列表赋值
-
-
/
/ 访问
-
int front
= d
1.front();
/
/ 访问第一个元素
-
int back
= d
1.back();
/
/ 访问最后一个元素
-
int
value
= d
1[
0];
/
/ 通过索引访问
-
value
= d
1.
at(
1);
/
/ 通过
at方法访问，如果索引越界会抛出异常
-
-
/
/ 插入
-
d
1.push_back(
10);
/
/ 在末尾插入元素
-
d
1.push_front(
11);
/
/ 在前端插入元素
-
d
1.insert(d
1.begin()
+
1,
12);
/
/ 在指定位置插入元素
-
-
/
/ 删除
-
d
1.pop_back();
/
/ 删除最后一个元素
-
d
1.pop_front();
/
/ 删除第一个元素
-
d
1.erase(d
1.begin());
/
/ 删除迭代器指定的元素
-
-
/
/ 修改
-
d
1[
0]
=
13;
/
/ 修改指定索引的元素
9337
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
