C++: STL容器及对应操作函数

月咏倾江华

已于 2024-08-04 15:34:25 修改

阅读量1.1k

点赞数 33

分类专栏： C++知识文章标签： c++

于 2024-08-04 15:02:34 首次发布

本文链接：https://blog.csdn.net/weixin_53442127/article/details/140905694

版权

C++知识专栏收录该内容

9 篇文章 0 订阅

订阅专栏

本文讲解C++中的STL容器和它们对应的操作函数。希望可以帮助大家。

一、前言

二、正文

① 顺序容器（Sequence Containers）

② 关联容器（Associative Containers）

③ 无序容器（Unordered Containers）

1.std::unordered_set

2.std::unordered_multiset

3.std::unordered_map

3.std::unordered_multimap

④ 容器适配器（Container Adapters）

1.std::stack

2.std::queue

3.std::priority_queue

三、总结

前言

C++标准库（STL，Standard Template Library）提供了一组通用的容器类，用于存储和管理数据。每种容器都有一组特定的操作函数，用于插入、删除、访问和遍历元素。以下是C++中常用的容器及其对应的操作函数的简要介绍：

正文

顺序容器（Sequence Containers）

`1.std::vector`

动态数组，支持快速随机访问。
元素在末尾插入和删除的时间复杂度为摊销常数时间。
适用于需要频繁随机访问和在末尾插入/删除元素的场景。

常用操作函数：

#include <vector>

std::vector<int> vec = {1, 2, 3, 4, 5};

vec.push_back(6); // 在末尾插入元素

vec.pop_back(); // 删除末尾元素

int val = vec.at(2); // 访问指定位置的元素

int size = vec.size(); // 获取元素个数

vec.clear(); // 清空所有元素

`2.std::deque`

双端队列，支持在两端快速插入和删除。
支持快速随机访问。
适用于需要在两端插入/删除元素的场景。

常用操作函数：

#include <deque>

std::deque<int> deq = {1, 2, 3, 4, 5};

deq.push_back(6); // 在末尾插入元素

deq.push_front(0); // 在前端插入元素

deq.pop_back(); // 删除末尾元素

deq.pop_front(); // 删除前端元素

int val = deq.at(2); // 访问指定位置的元素

int size = deq.size(); // 获取元素个数

deq.clear(); // 清空所有元素

3.std::list

双向链表，支持在任何位置快速插入和删除。
不支持随机访问。
适用于需要频繁在中间插入/删除元素的场景。

常用操作函数：

#include <list>

std::list<int> lst = {1, 2, 3, 4, 5};

lst.push_back(6); // 在末尾插入元素

lst.push_front(0); // 在前端插入元素

lst.pop_back(); // 删除末尾元素

lst.pop_front(); // 删除前端元素

int size = lst.size(); // 获取元素个数

lst.clear(); // 清空所有元素

4.std::forward_list

单向链表，支持在任何位置快速插入和删除。
不支持随机访问。
适用于需要频繁在中间插入/删除元素且内存使用较少的场景。

常用操作函数：

#include <forward_list>

std::forward_list<int> flst = {1, 2, 3, 4, 5};

flst.push_front(0); // 在前端插入元素

flst.pop_front(); // 删除前端元素

flst.clear(); // 清空所有元素

关联容器（Associative Containers）

1.std::set

有序集合，存储唯一的元素。
元素按键值排序。
适用于需要快速查找和唯一性保证的场景。

常用操作函数：

#include <set>

std::set<int> s = {1, 2, 3, 4, 5};

s.insert(6); // 插入元素

s.erase(3); // 删除元素

bool found = s.count(2); // 查找元素

int size = s.size(); // 获取元素个数

s.clear(); // 清空所有元素

2.std::multiset

有序集合，允许存储重复的元素。
元素按键值排序。
适用于需要快速查找和允许重复元素的场景。

常用操作函数：

#include <set>

std::multiset<int> ms = {1, 2, 2, 3, 4, 5};

ms.insert(6); // 插入元素

ms.erase(2); // 删除元素

int count = ms.count(2); // 查找元素

int size = ms.size(); // 获取元素个数

ms.clear(); // 清空所有元素

3.std::map

有序映射，存储键值对，键唯一。
元素按键值排序。
适用于需要快速查找键值对的场景。

常用操作函数：

#include <map>

std::map<int, std::string> m = {{1, "one"}, {2, "two"}, {3, "three"}};

m.insert({4, "four"}); // 插入键值对

m.erase(2); // 删除键值对

std::string val = m[1]; // 访问元素

int size = m.size(); // 获取元素个数

m.clear(); // 清空所有元素

4.std::multimap

有序映射，允许存储重复的键值对。
元素按键值排序。
适用于需要快速查找键值对且允许重复键的场景。

常用操作函数：

#include <map>

std::multimap<int, std::string> mm = {{1, "one"}, {1, "uno"}, {2, "two"}};

mm.insert({3, "three"}); // 插入键值对

mm.erase(1); // 删除键值对

int count = mm.count(1); // 查找元素

int size = mm.size(); // 获取元素个数

mm.clear(); // 清空所有元素

无序容器（Unordered Containers）

1.std::unordered_set

无序集合，存储唯一的元素。
元素按哈希值存储。
适用于需要快速查找和唯一性保证的场景。

常用操作函数：

#include <unordered_set>

std::unordered_set<int> us = {1, 2, 3, 4, 5};

us.insert(6); // 插入元素

us.erase(3); // 删除元素

bool found = us.count(2); // 查找元素

int size = us.size(); // 获取元素个数

us.clear(); // 清空所有元素

2.std::unordered_multiset

无序集合，允许存储重复的元素。
元素按哈希值存储。
适用于需要快速查找和允许重复元素的场景。

常用操作函数：

#include <unordered_set>

std::unordered_multiset<int> ums = {1, 2, 2, 3, 4, 5};

ums.insert(6); // 插入元素

ums.erase(2); // 删除元素

int count = ums.count(2); // 查找元素

int size = ums.size(); // 获取元素个数

ums.clear(); // 清空所有元素

3.std::unordered_map

无序映射，存储键值对，键唯一。
元素按哈希值存储。
适用于需要快速查找键值对的场景。

常用操作函数：

#include <unordered_map>

std::unordered_map<int, std::string> um = {{1, "one"}, {2, "two"}, {3, "three"}};

um.insert({4, "four"}); // 插入键值对

um.erase(2); // 删除键值对

std::string val = um[1]; // 访问元素

int size = um.size(); // 获取元素个数

um.clear(); // 清空所有元素

4.std::unordered_multimap

无序映射，允许存储重复的键值对。
元素按哈希值存储。
适用于需要快速查找键值对且允许重复键的场景。

常用操作函数：

#include <unordered_map>

std::unordered_multimap<int, std::string> umm = {{1, "one"}, {1, "uno"}, {2, "two"}};

umm.insert({3, "three"}); // 插入键值对

umm.erase(1); // 删除键值对

int count = umm.count(1); // 查找元素

int size = umm.size(); // 获取元素个数

umm.clear(); // 清空所有元素

容器适配器（Container Adapters）

1.std::stack

适配器，提供栈的功能（后进先出，LIFO）。
通常基于std::deque实现。

常用操作函数：

#include <stack>

std::stack<int> stk;

stk.push(1); // 压入元素

stk.push(2);

int top = stk.top(); // 访问栈顶元素

stk.pop(); // 弹出栈顶元素

bool empty = stk.empty();// 检查是否为空

int size = stk.size(); // 获取元素个数

2.std::queue

适配器，提供队列的功能（先进先出，FIFO）。
通常基于std::deque实现。

常用操作函数：

#include <queue>

std::queue<int> q;

q.push(1); // 入队元素

q.push(2);

int front = q.front(); // 访问队首元素

q.pop(); // 出队元素

bool empty = q.empty(); // 检查是否为空

int size = q.size(); // 获取元素个数

3.std::priority_queue

适配器，提供优先队列的功能。
通常基于std::vector实现。

常用操作函数：

#include <queue>

std::priority_queue<int> pq;

pq.push(1); // 插入元素

pq.push(2);

int top = pq.top(); // 访问队首元素

pq.pop(); // 删除队首元素

bool empty = pq.empty(); // 检查是否为空

int size = pq.size(); // 获取元素个数

总结

这些容器和操作函数提供了丰富的功能和灵活性，适用于各种不同的编程场景。选择合适的容器和操作函数可以显著提高程序的性能和可维护性。

月咏倾江华

关注

33
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
C++: STL容器及对应操作函数

C++标准库（STL，Standard Template Library）提供了一组通用的容器类，用于存储和管理数据。每种容器都有一组特定的操作函数，用于插入、删除、访问和遍历元素。这些容器和操作函数提供了丰富的功能和灵活性，适用于各种不同的编程场景。选择合适的容器和操作函数可以显著提高程序的性能和可维护性。
复制链接

扫一扫