# STL 基础、容器与迭代器

> [!info] 学习导航
> 返回：[[C++ 学习指南]]
> 前置知识：[[计算机系/C++/12 模板与模板元编程|模板与模板元编程]]

面向对象以类作为基础

泛型编程以模板作为基础

共同特点：重用代码

容器、迭代器、算法、迭代器、容器、函数对象

迭代器：内部类

外部类名:内部类名 成员函数名

| **迭代器类型** | **主要用途** | **类比**                             | **典型示例**                                                 |
| -------------- | ------------ | ------------------------------------ | ------------------------------------------------------------ |
| **输入迭代器** | **读取数据** | 程序从外部源（如容器）**读取**数据   | **istream_iterator**（从流读）类似于cin>>x  程序从标准输入流读取数据 |
| **输出迭代器** | **写入数据** | 程序向外部目标（如容器）中“输出”数据 | **ostream_iterator**（向流写）类似于cout<<x  程序向标准输出流输出数据 |

STL 的设计基于泛型编程，这意味着使用模板可以编写出独立于任何特定数据类型的代码。

STL 分为多个组件，包括容器（Containers）、迭代器（Iterators）、算法（Algorithms）、函数对象（Function Objects）和适配器（Adapters）等。

使用 STL 的好处:

- **代码复用**：STL 提供了大量的通用数据结构和算法，可以减少重复编写代码的工作。
- **性能优化**：STL 中的算法和数据结构都经过了优化，以提供最佳的性能。
- **泛型编程**：使用模板，STL 支持泛型编程，使得算法和数据结构可以适用于任何数据类型。
- **易于维护**：STL 的设计使得代码更加模块化，易于阅读和维护。

C++ 标准模板库的核心包括以下重要组件组件：

| **组件**                     | **描述**                                                     |
| ---------------------------- | ------------------------------------------------------------ |
| 容器（Containers）           | 容器是 STL 中最基本的组件之一，提供了各种数据结构，包括向量（vector）、链表（list）、队列（queue）、栈（stack）、集合（set）、映射（map）等。这些容器具有不同的特性和用途，可以根据实际需求选择合适的容器。 |
| 算法（Algorithms）           | STL  提供了大量的算法，用于对容器中的元素进行各种操作，包括排序、搜索、复制、移动、变换等。这些算法在使用时不需要关心容器的具体类型，只需要指定要操作的范围即可。 |
| 迭代器（iterators）          | 迭代器用于遍历容器中的元素，允许以统一的方式访问容器中的元素，而不用关心容器的内部实现细节。STL 提供了多种类型的迭代器，包括随机访问迭代器、双向迭代器、前向迭代器和输入输出迭代器等。 |
| 函数对象（Function Objects） | 函数对象是可以像函数一样调用的对象，可以用于算法中的各种操作。STL 提供了多种函数对象，包括一元函数对象、二元函数对象、谓词等，可以满足不同的需求。 |
| 适配器（Adapters）           | 适配器用于将一种容器或迭代器适配成另一种容器或迭代器，以满足特定的需求。STL 提供了多种适配器，包括栈适配器（stack adapter）、队列适配器（queue adapter）和优先队列适配器（priority queue  adapter）等。 |

这些个组件都带有丰富的预定义函数，帮助我们通过简单的方式处理复杂的任务。


## 容器

所谓容器就是一种对象，容器里存放到其他类型的对象称为容器里的元素

C++标准库以类模板的形式产生容器类

容器是用来存储数据的序列，它们提供了不同的存储方式和访问模式。


STL 中的容器可以分为三类：

1、序列容器：存储元素的序列，允许双向遍历。

- std::vector：动态数组，支持快速随机访问。
- std::deque：双端队列，支持快速插入和删除。
- std::list：链表，支持快速插入和删除，但不支持随机访问。

2、关联容器：存储键值对，每个元素都有一个键（key）和一个值（value），并且通过键来组织元素。

- std::set：集合，不允许重复元素。
- std::multiset：多重集合，允许多个元素具有相同的键。
- std::map：映射，每个键映射到一个值。
- std::multimap：多重映射，存储了键值对（pair），其中键是唯一的，但值可以重复，允许一个键映射到多个值。

3、无序容器（C++11 引入）：哈希表，支持快速的查找、插入和删除。

- std::unordered_set：无序集合。
- std::unordered_multiset：无序多重集合。
- std::unordered_map：无序映射。
- std::unordered_multimap：无序多重映射。

- **有序容器**（如 **std::map**）通常基于**红黑树**（一种平衡二叉搜索树），元素始终按键的严格弱序（默认是 **<** 比较）排序。
- **无序容器**基于**哈希表**（Hash Table），元素通过哈希函数计算存储位置，不保证顺序。

```cpp
#include <iostream>
#include <vector>
using namespace std;
int main()
{
// 创建一个向量存储 int
  vector<int> vec;
  int i;
// 显示 vec 的原始大小
  cout << "vector size = " << vec.size() << endl;
// 推入 5 个值到向量中
  for(i = 0; i < 5; i++){
   vec.push_back(i);
  }
// 显示 vec 扩展后的大小
  cout << "extended vector size = " << vec.size() << endl;
// 访问向量中的 5 个值
  for(i = 0; i < 5; i++){
   cout << "value of vec [" << i << "] = " << vec[i] << endl;
  }
// 使用迭代器 iterator 访问值
  vector<int>::iterator v = vec.begin();
  while( v != vec.end()) {
   cout << "value of v = " << *v << endl;
   v++;
  }
  return 0;
}
```

**size** 是当前 vector 容器真实占用的大小，也就是容器当前拥有多少个容器。

**capacity** 是指在发生 realloc 前能允许的最大元素数，即预分配的内存空间。

以vector为例，我们都知道可以用reserve()和resize()函数来为容器预留空间或者调整它的大小。

不过从它俩的名字上可以看出区别：

reserve()：serve是“保留”的词根，所以是用来保留，预留容量的，并不改变容器的有效元素个数。

resize()：size是“大小”的意思，它主要用来调整容易有效元素的个数，有时候也会造成容量变大。


先解释两个概念：

**容量**：即capacity，是指容器在自由内存中获得了多大的存储空间，容量为100并不代表容器就有100个元素，可能容量只有10个，剩下的90个都是闲置的未定义内存空间。

**大小**：即size，指的是容器中实际元素的个数，大小为100就代表容器有100个已经存在的元素。


当然，这两个属性分别对应两个方法：**resize ()**。

使用 **resize()** 容器内的对象内存空间是真正存在的。

使用 **reserve()** 仅仅只是修改了 capacity 的值，容器内的对象并没有真实的内存空间(空间是"野"的)。

此时切忌使用 **[]** 操作符访问容器内的对象，很可能出现数组越界的问题。

```cpp
#include <iostream>
#include <vector>
using std::vector;
int main(void)
{
  vector<int> v;
  std::cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << std::endl;
  v.reserve(10);
  std::cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << std::endl;
  v.resize(10);
  v.push_back(0);
  std::cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << std::endl;
  return 0;
}
```

![img](data:image/png;base64,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)

| **特性**     | **#include**   | **模块（import）**   |
| ------------ | -------------- | -------------------- |
| 编译速度     | 慢（重复解析） | 快（二进制接口复用） |
| 命名空间污染 | 严重           | 隔离性好             |
| 依赖管理     | 隐式           | 显式                 |
| 宏泄漏       | 是             | 否                   |
| 标准库支持   | 全部头文件     | C++23  起逐步模块化  |

## 迭代器

C++ 标准库中的 \<iterator> 头文件提供了一组工具，用于遍历容器中的元素。迭代器是 C++ 标准模板库（STL）中的核心概念之一，它允许程序员以统一的方式访问容器中的元素，而不需要关心容器的具体实现细节。

迭代器是一个对象，它提供了一种方法来遍历容器中的元素。迭代器可以被视为指向容器中元素的指针，但它比指针更加灵活和强大。迭代器可以用于访问、修改容器中的元素，并且可以与 STL 算法一起使用。

迭代器主要分为以下几类：

1. **输入迭代器（Input Iterator）**：只能进行单次读取操作，不能进行写入操作。
2. **输出迭代器（Output Iterator）**：只能进行单次写入操作，不能进行读取操作。
3. **正向迭代器（Forward Iterator）**：可以进行读取和写入操作，并且可以向前移动。
4. **双向迭代器（Bidirectional Iterator）**：除了可以进行正向迭代器的所有操作外，还可以向后移动。
5. **随机访问迭代器（Random Access Iterator）**：除了可以进行双向迭代器的所有操作外，还可以进行随机访问，例如通过下标访问元素。

每种容器类型都定义了自己的迭代器类型，如vector:
 vector\<int>::iterator iter;这条语句定义了一个名为iter的变量，它的数据类型是由vector\<int>定义的iterator类型。

```cpp
#include <iterator>
```

迭代器是一种泛型指针对象，可以通过迭代器访问所在未知元素，也可以通过迭代器操作更新位置。


```cpp
// 使用迭代器遍历容器
for (ContainerType::iterator it = container.begin(); it != container.end(); ++it) {
// 访问元素 *it
}
#include <iostream>
#include <vector>
#include <iterator>
int main() {
// 创建一个 vector 容器并初始化
  std::vector<int> vec = {1, 2, 3, 4, 5};
// 使用迭代器遍历 vector
  for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << " ";
  }
  std::cout << std::endl;
// 使用 auto 关键字简化迭代器类型
  for (auto it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << " ";
  }
  std::cout << std::endl;
// 使用 C++11 范围 for 循环
  for (int elem : vec) {
    std::cout << elem << " ";
  }
  std::cout << std::endl;
  return 0;
```

}通过使用 \<iterator> 头文件，我们可以方便地遍历 C++ STL 容器中的元素。迭代器提供了一种统一的接口，使得我们可以在不同的容器之间切换，而不需要改变遍历的代码。这大大提高了代码的可重用性和可维护性。

```cpp
vector<int> ivec(10,1);
for(vector<int>::iterator iter=ivec.begin();iter!=ivec.end();++iter)
{
*iter=2; // 使用 * 访问迭代器所指向的元素
}
```

const_iterator:

只能读取容器中的元素，而不能修改。

```cpp
for(vector<int>::const_iterator citer=ivec.begin();citer!=ivec.end();citer++)
{
cout<<*citer;
// citer=3; error
}
```

vector\<int>::const_iterator 和 const vector\<int>::iterator的区别

```cpp
const vector<int>::iterator newiter=ivec.begin();
*newiter=11; // 可以修改指向容器的元素
```

 vector 和deque提供的是RandomAccessIterator，list提供的是BidirectionalIterator，set和map提供的 iterators是 ForwardIterator

### 迭代器的常用操作

(1)所有迭代器

p++               后置自增迭代器

++p               前置自增迭代器

(2)输入迭代器

\*p                 复引用迭代器，作为右值

p=p1               将一个迭代器赋给另一个迭代器

p\==p1              比较迭代器的相等性

p!=p1              比较迭代器的不等性

(3)输出迭代器

\*p                 复引用迭代器，作为左值

p=p1               将一个迭代器赋给另一个迭代器

(4)正向迭代器

提供输入输出迭代器的所有功能

(5)双向迭代器

--p                前置自减迭代器

p--                后置自减迭代器

(6)随机迭代器

p+=i               将迭代器递增i位

p-=i                将迭代器递减i位

p+i                在p位加i位后的迭代器

p-i                 在p位减i位后的迭代器

p[i]                返回p位元素偏离i位的元素引用

p<p1               如果迭代器p的位置在p1前，返回true，否则返回false

p<=p1              p的位置在p1的前面或同一位置时返回true，否则返回false

p>p1               如果迭代器p的位置在p1后，返回true，否则返回false

p>=p1              p的位置在p1的后面或同一位置时返回true，否则返回false

  只有顺序容器和关联容器支持迭代器遍历，各容器支持的迭代器的类别如下：

容器         支持的迭代器类别      容器        支持的迭代器类别      容器         支持的迭代器类别

vector       随机访问           deque       随机访问            list          双向

set          双向              multiset      双向              map         双向

multimap     双向               stack        不支持            queue       不支持

priority_queue  不支持


**![img](data:image/png;base64,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)**

## 相关内容
- [[计算机系/C++/15 STL 常用容器|STL 常用容器]]
- [[计算机系/C++/16 STL 算法、函数对象与 Lambda|STL 算法、函数对象与 Lambda]]

---

## 学习导航
- 上一篇：[[计算机系/C++/13 异常处理与智能指针|异常处理与智能指针]]
- 返回目录：[[C++ 学习指南]]
- 下一篇：[[计算机系/C++/15 STL 常用容器|STL 常用容器]]