C++ 标准模板库的核心包括以下三个组件：
- **容器（Containers）**: 容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。
- **算法（Algorithms）**: 算法作用于容器。它们提供了执行各种操作的方式，包括对容器内容执行初始化、排序、搜索和转换等操作。
- **迭代器（iterators）**: 迭代器用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。
这三个组件都带有丰富的预定义函数，帮助我们通过简单的方式处理复杂的任务。
## C++ STL 常用容器
- `vector`：向量
- `stack`：栈
- `set`：集合
- `queue`：队列
- `list`：双向链表
- `map`：地图
- `pair`：对
- `string`：字符串
- `deque`：双端队列
- `priority_queue`：优先队列
对于容器，主要的操作有：
- 容器的建立
- 插入元素
- 删除元素
- 查询
- 遍历
- 计算元素个数
- 检查元素是否为空
- 输出容器包含的内容
## vector
`vector`包含着一系列连续存储的元素, 其行为和数组类似。访问 Vector 中的任意元素或从末尾添加元素都可以在`常量级时间复杂度`内完成，而查找特定值的元素所处的位置或是在 Vector 中插入元素则是`线性时间复杂度`。
### 构造函数:
- `vector();` 无参数 - 构造一个空的 vector
- `vector(size_type num);` 数量 (num) - 构造一个大小为 num，值为 Type 默认值的 Vector
- `vector(size_type num, const TYPE &val);` 数量 (num) 和值(val) - 构造一个初始放入 num 个值为 val 的元素的 Vector
- `vector(const vector &from);` vector(from) - 构造一个与 vector from 相同的 vector
- `vector(input_iterator start, input_iterator end);` 迭代器 (start) 和迭代器 (end) - 构造一个初始值为[start,end) 区间元素的 Vector(注: 半开区间).
- `vector(initializer_list
C++11 新提供的方法，类似如下方式：
- `std::vector
- `std::vector
### 常用 API：
- Operators : 对 vector 进行赋值或比较
- `v1 == v2`
- `v1 != v2`
- `v1 <= v2`
- `v1 >= v2`
- `v1 < v2`
- `v1 > v2`
- `v[]`
- `assign()`对 Vector 中的元素赋值
- `at()` : 返回指定位置的元素
- `back()` : 返回最末一个元素
- `begin()` : 返回第一个元素的迭代器
- `capacity()` : 返回 vector 所能容纳的元素数量 (在不重新分配内存的情况下）
- `clear()` : 清空所有元素
- `empty()` : 判断 Vector 是否为空（返回 true 时为空）
- `end()` : 返回最末元素的迭代器 (译注: 实指向最末元素的下一个位置)
- `erase()` : 删除指定元素
- `front()` : 返回第一个元素
- `get_allocator()` : 返回 vector 的内存分配器
- `insert()` : 插入元素到 Vector 中
- `max_size()` : 返回 Vector 所能容纳元素的最大数量（上限）
- `pop_back()` : 移除最后一个元素
- `push_back()` : 在 Vector 最后添加一个元素
- `rbegin()` : 返回 Vector 尾部的逆迭代器
- `rend()` : 返回 Vector 起始的逆迭代器
- `reserve()` : 设置 Vector 最小的元素容纳数量
- `resize()` : 改变 Vector 元素数量的大小
- `size()` : 返回 Vector 元素数量的大小
- `swap()` : 交换两个 Vector
## stack
C++ stack（堆栈）实现了一个**先进后出**（FILO）的数据结构。
### 构造函数：
- `stack
- `stack(const stack &stk);` : 拷贝构造函数
### 常用方法：
- `size()`: 返回栈中的元素数
- `top()`: 返回栈顶的元素
- `pop()`: 从栈中取出并删除元素
- `push(x)`: 向栈中添加元素 x
- `empty()`: 在栈为空时返回 true
## set
Sets are containers that store unique elements following a specific order.
集合中以一种特定的顺序保存唯一的元素。
### 构造函数:
- `set();` 无参数 - 构造一个空的 set
- `set(InputIterator first, InputIterator last)` : 迭代器的方式构造 set
- `set(const set &from);` : copyd 的方式构造一个与 set from 相同的 set
- `set(input_iterator start, input_iterator end);` 迭代器 (start) 和迭代器 (end) - 构造一个初始值为[start,end) 区间元素的 Vector(注: 半开区间).
- `set (initializer_list
- `std::set
example:
```cpp
#include
#include
bool fncomp (int lhs, int rhs) {return lhs struct classcomp { int main () int myints[]= {10,20,30,40,50}; std::set std::set std::set bool(*fn_pt)(int,int) = fncomp; return 0; ### 常用 API： - `begin()` : 返回指向第一个元素的迭代器 ## queue C++ 队列是一种容器适配器，它给予程序员一种先进先出 (FIFO) 的数据结构。 ### 构造函数： - `explicit queue (const container_type& ctnr);` example: ```cpp int main () std::queue std::queue std::cout << "size of first: " << first.size() << '\n'; return 0; Output: ```cpp ### 常用 API： - `back()` : 返回最后一个元素 ## list Lists 将元素按顺序储存在链表中. 与 向量 (vectors) 相比, 它允许快速的插入和删除，但是随机访问却比较慢. ### 构造函数： - `list (const allocator_type& alloc = allocator_type());` ### 常用 API： - `assign()` : 给 list 赋值 ## map C++ Maps 是一种关联式容器，包含 “关键字 / 值” 对 从 map 中提取元素时，得到一个 pair 类型对象 ### 构造函数： - `map (const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type());` example: ```cpp int main() // 插入数据的三种方式 // 判断是否有元素 // 遍历 // 查找 if((iter=dict.find("banana"))!=dict.end()) return 0; ### 常用 API： - `begin()` : 返回指向 map 头部的迭代器 ## pair 把两个元素绑定一起，但又不想定义结构体 > 头文件 `#include `make_pair ## 构造函数 ```cpp ### 常用 api ```cpp // 初始化 // 比较 ## string ### 1.string 构造函数 - `string();`// 创建一个空的字符串 ### 2.string 基本赋值操作 - `string& operator=(const char* s);`//char * 类型字符串 赋值给当前的字符串 ### 3.string 存取字符操作 - `char& operator[](int n);`// 通过`[]`方式取字符 ### 4.string 拼接操作 - `string& operator+=(const string& str);`// 重载 += 运算符 ### 5.string 查找和替换 - `int find(const string& str,int pos = 0)const;`// 查找 str 第一次出现的位置，从 pos 开始查找 ### 6.string 比较操作 - `int compare(const string &s)const;`// 与字符串 s 比较 ### 7.string 子串 - `string substr(int pos = 0,int n = npos)const;`// 返回由 pos 开始的 n 个字符组成的字符串 ### 8.string 插入和删除操作 - `string& insert(int pos,const char* s);`// 插入字符串 ## deque deque 是 Double-Ended Queues(双向队列) 的缩写。 双向队列和向量很相似，但是它允许在容器头部快速插入和删除（就像在尾部一样）。 ### 1.deque 构造函数 - `deque example: ```cpp int main () std::deque int myints[] = {16,2,77,29}; std::cout << "The contents of fifth are:"; std::cout << '\n'; return 0; Output: ``` ### 2.deque 存取、插入和删除操作 - `back();`// 返回最后一个元素 > 注：queue 只有 push 和 pop 方法，在尾部加入和删除元素。 ### 3.deque 赋值操作 - `operator[] (size_type n);`// 重载 [] 操作符 ### 4.deque 大小操作 - `empty()`;// 判断队列是否为空 ## priority_queue 优先队列类似队列， 但是在这个数据结构中的元素按照一定的规则排列有序。 在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有**最高优先级先出** （first in, largest out）的行为特征。 首先要包含头文件 #include, 他和 queue 不同的就在于我们可以自定义其中数据的优先级, 让优先级高的排在队列前面, 优先出队。 优先队列具有队列的所有特性，包括队列的基本操作，只是在这基础上添加了内部的一个排序，它**本质是一个堆实现的**。 构造函数： `priority_queue - Type 就是数据类型， 当需要用自定义的数据类型时才需要传入这三个参数，使用基本数据类型时，只需要传入数据类型，默认是大顶堆 (Functional 是 less)。 example: ```cpp class mycomparison int main () std::priority_queue typedef std::priority_queue mypq_type fourth; return 0; api 和队列基本操作相同: - `top` 访问队头元素 转载：[来源](http://vernlium.github.io/2019/12/29/C-STL%E5%B8%B8%E7%94%A8%E5%AE%B9%E5%99%A8API%E6%80%BB%E7%BB%93/)
bool operator() (const int& lhs, const int& rhs) const
{return lhs
{
std::set
std::set
std::set
}
```
- `clear()` : 清除所有元素
- `count()` : 返回某个值元素的个数
- `empty()` : 如果集合为空，返回 true
- `end()` : 返回指向最后一个元素的迭代器
- `equal_range()` : 返回集合中与给定值相等的上下限的两个迭代器
- `erase()` : 删除集合中的元素
- `find()` : 返回一个指向被查找到元素的迭代器（***`没有找到时返回 end() 迭代器`***）
- `get_allocator()` : 返回集合的分配器
- `insert()` : 在集合中插入元素
- `lower_bound()` : 返回指向大于（或等于）某值的第一个元素的迭代器
- `key_comp()` : 返回一个用于元素间值比较的函数
- `max_size()` : 返回集合能容纳的元素的最大限值
- `rbegin()` : 返回指向集合中最后一个元素的反向迭代器
- `rend()` : 返回指向集合中第一个元素的反向迭代器
- `size()` : 集合中元素的数目
- `swap()` : 交换两个集合变量
- `upper_bound()` : 返回大于某个值元素的迭代器
- `value_comp()` : 返回一个用于比较元素间的值的函数
- `explicit queue (container_type&& ctnr = container_type());`
- `template
- `template
- `template
- `template
- `template
#include
#include
#include // std::list
#include
{
std::deque
std::list
std::queue
std::queue
std::cout << "size of second: " << second.size() << '\n';
std::cout << "size of third: " << third.size() << '\n';
std::cout << "size of fourth: " << fourth.size() << '\n';
}
```
size of first: 0
size of second: 3
size of third: 0
size of fourth: 2
```
- `empty()` : 如果队列空则返回真
- `front()` : 返回第一个元素
- `pop()` : 删除第一个元素
- `push()` : 在末尾加入一个元素
- `size()` : 返回队列中元素的个数
- `list (size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type());`
- `template
- `list (const list& x);`
- `back()` : 返回最后一个元素
- `begin()` : 返回指向第一个元素的迭代器
- `clear()` : 删除所有元素
- `empty()` : 如果 list 是空的则返回 true
- `end()` : 返回末尾的迭代器
- `erase()` : 删除一个元素
- `front()` : 返回第一个元素
- `get_allocator()` : 返回 list 的配置器
- `insert()` : 插入一个元素到 list 中
- `max_size()` : 返回 list 能容纳的最大元素数量
- `merge()` : 合并两个 list
- `pop_back()` : 删除最后一个元素
- `pop_front()` : 删除第一个元素
- `push_back()` : 在 list 的末尾添加一个元素
- `push_front()` : 在 list 的头部添加一个元素
- `rbegin()` : 返回指向第一个元素的逆向迭代器
- `remove()` : 从 list 删除元素
- `remove_if()` : 按指定条件删除元素
- `rend()` : 指向 list 末尾的逆向迭代器
- `resize()` : 改变 list 的大小
- `reverse()` : 把 list 的元素倒转
- `size()` : 返回 list 中的元素个数
- `sort()` : 给 list 排序
- `splice()` : 合并两个 list
- `swap()` : 交换两个 list
- `unique()` : 删除 list 中重复的元素
- `template
- `map (const map& x);`
- `map (const map& x, const allocator_type& alloc);`
- `map (map&& x);`
- `map (map&& x, const allocator_type& alloc);`
- `map (initializer_list
#include
#include
#include
using namespace std;
{
unordered_map
dict.insert(pair
dict.insert(unordered_map
dict["banana"] = 6;
if(dict.empty())
cout<<"该字典无元素"<
cout<<"该字典共有"<
unordered_map
for(iter=dict.begin();iter!=dict.end();iter++)
cout<
if(dict.count("boluo")==0)
cout<<"can't find boluo!"<
cout<<"find boluo!"<
cout<<"banana="<
cout<<"can't find boluo!"<
}
```
- `clear()` : 删除所有元素
- `count()` : 返回指定元素出现的次数
- `empty()` : 如果 map 为空则返回 true
- `end()` : 返回指向 map 末尾的迭代器
- `equal_range()` : 返回特殊条目的迭代器对
- `erase()` : 删除一个元素
- `find()` : 查找一个元素
- `get_allocator()` : 返回 map 的配置器
- `insert()` : 插入元素–
- `key_comp()` : 返回比较元素 key 的函数
- `lower_bound()` : 返回键值 >= 给定元素的第一个位置
- `max_size()` : 返回可以容纳的最大元素个数
- `rbegin()` : 返回一个指向 map 尾部的逆向迭代器
- `rend()` : 返回一个指向 map 头部的逆向迭代器
- `size()` : 返回 map 中元素的个数
- `swap()` : 交换两个 map
- `upper_bound()` : 返回键值 > 给定元素的第一个位置
- `value_comp()` : 返回比较元素 value 的函数
> 也可用
返回一个以 v1 和 v2 初始化的 pair，pair 类型从值的类型推断出来
// 定义
pair
pair
pair
```
// 访问元素 没有（）
p1.first;
p2.second;
p2 = make_pair("world",1);
p3 = pair
// pair 类型数据可以直接使用比较运算符比较时
// 先比较 first，相等时再比较 second
```
- `string(const string& str);`// 使用一个 string 对象初始化另一个 string 对象
- `string(const char* s);`// 使用字符串 s 初始化
- `string(int n,char c);`// 使用 n 个字符 c 初始化
- `string& operator=(const string &s);`// 把字符串 s 赋值给当前的字符串
- `string& operator=(char c);`// 字符赋值给当前的字符串
- `string& assign(const char* s);`// 把字符串 s 赋值给当前的字符串
- `string& assign(const char* s,int n);`// 把字符串 s 的前 n 个字符赋值给当前的字符串
- `string& assign(const string &s);`// 把字符串 s 赋值给当前的字符串
- `string& assign(int n,char c);`// 用 n 个字符 c 赋值给当前字符串
- `string& assign(const string &s,int start,int n);`// 将 s 从 start 开始 n 个字符赋值给字符串
- `char& at(int n);`// 通过 at 方法获取字符
- `string& operator+=(const char* str);`// 重载 += 运算符
- `string& operator+=(const char c);`// 重载 += 运算符
- `string& append(const char *s);`// 把字符串 s 连接到当前字符串结尾
- `string& append(const char *s,int n);`// 把字符串 s 的前 n 个字符连接到当前字符串结尾
- `string& append(const string &s);`// 同 operator+=（）
- `string& append(const string &s,int pos,int n);`// 把字符串 s 中从 pos 开始的 n 个字符连接到当前字符串结尾
- `string& append(int n,char c);`// 在当前字符串结尾添加 n 个字符 c
- `int find(const char* s,int pos = 0)const;`// 查找 s 第一次出现位置，从 pos 开始查找
- `int find(const char *s,int pos,int n)const;`// 从 pos 位置查找 s 的前 n 个字符第一次位置
- `int find(const char c,int pos = 0)const;`// 查找字符 c 第一次出现位置
- `int rfind(const string& str, int pos = npos)const;`// 查找 str 最后一次出现位置，从 pos 开始查找
- `int rfind(const char* s,int pos = npos)const;`// 查找 s 最后一次出现位置，从 pos 开始查找
- `int rfind(const char* s,int pos,int n )const;`// 从 pos 查找 s 的前 n 个字符最后一次位置
- `int rfind(const char c,int pos = 0)const;`// 查找字符 c 最后一次出现位置
- `string& replace(int pos,int n,const string& str);`// 替换从 pos 开始的 n 个字符为字符串 str
- `string& replace(int pos,int n,const char* s);`// 替换从 pos 开始的 n 个字符为字符串 s
- `int compare(const char*s)const;`// 与字符串 s 比较
- compare 函数在 > 时返回 1，< 时返回 - 1，相等时返回 0，比较区分大小写，逐个字符比较
- `string& insert(int pos,const string &str);`// 插入字符串
- `string& insert(int pos,int n,char c);`// 在指定位置插入 n 个字符 c
- `string& erase(int pos,int n = npos);`// 删除从 pos 开始的 n 个字符
- `deque
- `deque
- `deque(const deque &que);`// 拷贝构造函数
- `deque(input_iterator start, input_iterator end);`// 迭代器构造函数
#include
#include
{
unsigned int i;
std::deque
std::deque
std::deque
std::deque
for (std::deque
std::cout << ' ' << *it;
}
```
The contents of fifth are: 16 2 77 29
```
- `front();`// 返回第一个元素
- `insert();`//
- `pop_back();`// 删除尾部的元素
- `pop_front();`// 删除头部的元素
- `push_back();`// 在尾部加入一个元素
- `push_front();`// 在头部加入一个元素
- `at();`// 访问指定位置元素
- `size()`;// 返回队列的大小
- Container 就是容器类型（Container 必须是具备**随机存取**能力的容器，支持如下方法：`empty()`, `size()`, `front()`, `push_back()`,`pop_back()`。比如 vector,deque 等等，但不能用 list。STL 里面默认用的是 vector）。可选
- Functional 就是比较的方式。可选
#include
#include
#include
#include
{
bool reverse;
public:
mycomparison(const bool& revparam=false)
{reverse=revparam;}
bool operator() (const int& lhs, const int&rhs) const
{
if (reverse) return (lhs>rhs);
else return (lhs
};
{
int myints[]= {10,60,50,20};
std::priority_queue
std::priority_queue
third (myints,myints+4);
mypq_type fifth (mycomparison(true));
}
```
- `empty` 队列是否为空
- `size` 返回队列内元素个数
- `push` 插入元素到队尾 (并排序)
- `emplace` 原地构造一个元素并插入队列
- `pop` 弹出队头元素
- `swap` 交换内容
1 条评论
独特的构思和新颖的观点，让这篇文章在众多作品中脱颖而出。