C++从入门到实战（十九）C++ vector容器及其常用接口

C++从入门到实战（十九）C++ vector容器及其常用接口

• 前言
• 一、什么是vector
• 二、vector的构造接口
• • 1. 默认构造函数：创建空vector
  • 2. 带大小的构造：创建指定长度的vector
  • 3. 带大小和初始值的构造：指定长度+统一初始值
  • 4. 迭代器范围构造：从其他容器复制元素
  • 5. 拷贝构造：复制已有vector
  • 6. 列表初始化（C++11起）：直接指定元素
  • 总结：vector构造方式对比
• 三、vector的遍历方法
• • 1. 下标访问（operator[]）
  • 2. at() 访问（安全版下标）
  • 3. 迭代器遍历（重点掌握）
  • • 3.1 正向迭代器（begin()` / `end()`）
    • 3.2 反向迭代器（`rbegin()` / `rend()`）
    • 3.3 const迭代器（只读访问）
  • 4. 范围for循环（C++11起，最简洁）
  • 总结：遍历方式对比
• 四、vector的容量管理
• • 1. size()：获取实际元素个数
  • 2. capacity()：获取当前分配的容量
  • 3. empty()：判断是否为空
  • 4. reserve(n)：预分配容量
  • 5. resize(n) / resize(n, val)：调整大小
  • 6. shrink_to_fit()：释放多余内存
  • 7. max_size()：理论最大容量
  • 总结：容量管理核心接口
  • • 底层扩容机制（了解）
• 五、vector的元素修改
• • 1. push_back()：尾部添加元素
  • 2. pop_back()：尾部删除元素
  • 3. insert()：指定位置插入元素
  • 4. erase()：删除指定位置元素
  • 5. swap()：交换两个vector
  • 6. clear()：清空所有元素

---

前言

• 前面我们已经学习了C++中String的诸多知识点，了解了它作为动态字符串的特性与常用操作。
• 接下来，我们将探讨C++ STL中另一个核心容器——vector。它与string在底层实现和接口设计上有诸多相似之处，但功能更通用：string专为字符设计，而vector可存储任意类型的数据。
• 本篇将深入解析vector的核心概念、构造方式、遍历方法及容量管理，为后续复杂容器的学习打下基础。

我的个人主页，欢迎来阅读我的其他文章
https://blog.csdn.net/2402_83322742?spm=1011.2415.3001.5343
我的C++知识文章专栏
欢迎来阅读指出不足
https://blog.csdn.net/2402_83322742/category_12880513.html?spm=1001.2014.3001.5482

---

C++官方vector文档
https://cplusplus.com/reference/vector/vector/

一、什么是vector

std::vector 是C++ STL（标准模板库）中的动态数组容器，可以理解为“能自动扩容的数组”。

• 与C语言的静态数组相比，vector无需手动指定大小，会根据元素数量自动调整内存空间。
• 与string相比，vector是模板类（template ），可存储任意类型（int、double、自定义对象等），而string仅存储char。
• 本质上，vector是“顺序表”的实现：元素在内存中连续存储，支持随机访问（通过下标快速访问任意元素）。

C++官方vector文档
https://cplusplus.com/reference/vector/vector/

二、vector的构造接口

vector提供了多种构造方式，可根据不同场景灵活初始化。以下是最常用的构造函数：

1. 默认构造函数：创建空vector

vector<T>(); // T为存储的元素类型（如int、string等）

作用：创建一个空的vector，不含任何元素，大小为0。
例子：

#include #include #include using namespace std;int main() { vector<int> v1; // 空vector（存储int类型） vector<string> v2; // 空vector（存储string类型） return 0;}

2. 带大小的构造：创建指定长度的vector

vector<T>(size_t n);

作用：创建一个包含 n 个元素的vector，元素值为默认初始化（内置类型为0，自定义类型调用默认构造）。
例子：

vector<int> v(5); // 包含5个int，默认值为0for (int num : v) { cout << num << \" \"; // 输出：0 0 0 0 0}

3. 带大小和初始值的构造：指定长度+统一初始值

vector<T>(size_t n, const T& val);

作用：创建包含 n 个元素的vector，每个元素的值均为 val。
例子：

vector<int> v(3, 10); // 3个元素，每个都是10for (int num : v) { cout << num << \" \"; // 输出：10 10 10}

4. 迭代器范围构造：从其他容器复制元素

template <class InputIterator>vector<T>(InputIterator first, InputIterator last);

作用：复制另一个容器（如vector、string、数组）中 [first, last) 范围内的元素。
例子：

// 从数组构造int arr[] = {1, 2, 3, 4};vector<int> v1(arr, arr + 4); // 复制arr的所有元素// 从另一个vector构造vector<int> v2(v1.begin(), v1.end()); // 复制v1的所有元素for (int num : v2) { cout << num << \" \"; // 输出：1 2 3 4}

5. 拷贝构造：复制已有vector

vector<T>(const vector<T>& other);

作用：创建一个与 other 完全相同的vector（元素值和大小均一致）。
例子：

vector<int> v1 = {1, 2, 3}; // 初始化v1vector<int> v2(v1); // 拷贝构造，v2与v1相同for (int num : v2) { cout << num << \" \"; // 输出：1 2 3}

6. 列表初始化（C++11起）：直接指定元素

vector<T> v = {a, b, c, ...}; // 或 vector v{a, b, c, ...};

作用：用初始化列表中的元素直接构造vector，元素顺序与列表一致。
例子：

vector<int> v = {10, 20, 30}; // 3个元素：10,20,30vector<string> vs{\"hello\", \"world\"}; // 2个string元素for (int num : v) { cout << num << \" \"; // 输出：10 20 30}

总结：vector构造方式对比

构造方式 语法示例 适用场景 默认构造 vector v; 初始为空，后续动态添加元素 带大小构造 vector v(5); 需要固定长度，元素默认初始化 大小+初始值构造 vector v(3, 10); 固定长度，元素值相同 迭代器范围构造 vector v(arr, arr+4); 从其他容器复制元素 拷贝构造 vector v(other); 复制已有vector 列表初始化（C++11） vector v{1,2,3}; 已知初始元素，简洁直观

三、vector的遍历方法

vector支持多种遍历方式，与string类似，核心是通过下标、迭代器或范围for访问元素。

1. 下标访问（operator[]）

语法：v[i]（i 为索引，从0开始）
特点：与数组用法一致，不检查越界（越界访问会导致未定义行为）。
例子：

vector<int> v = {1, 2, 3, 4, 5};for (size_t i = 0; i < v.size(); ++i) { cout << v[i] << \" \"; // 输出：1 2 3 4 5}

2. at() 访问（安全版下标）

语法：v.at(i)
特点：与 v[i] 功能相同，但会检查越界（越界时抛出 out_of_range 异常）。
例子：

vector<int> v = {1, 2, 3};try { cout << v.at(2) << endl; // 输出：3（合法访问） cout << v.at(5) << endl; // 越界，抛出异常} catch (const out_of_range& e) { cout << \"错误：\" << e.what() << endl; // 捕获异常}

3. 迭代器遍历（重点掌握）

迭代器是STL容器的通用访问方式，vector的迭代器用法与string几乎一致。

3.1 正向迭代器（begin()/end()`）

• begin()：指向第一个元素的迭代器。
• end()：指向最后一个元素下一个位置的迭代器（不包含元素）。

例子：

vector<int> v = {1, 2, 3};// 正向遍历for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) { cout << *it << \" \"; // *it 访问当前元素，输出：1 2 3}

简化写法（auto 自动推导类型）：

for (auto it = v.begin(); it != v.end(); ++it) { cout << *it << \" \"; // 效果同上}

3.2 反向迭代器（rbegin() / rend()）

• rbegin()：指向最后一个元素的反向迭代器。
• rend()：指向第一个元素前一个位置的反向迭代器。

例子：

vector<int> v = {1, 2, 3};// 反向遍历（从后往前）for (vector<int>::reverse_iterator rit = v.rbegin(); rit != v.rend(); ++rit) { cout << *rit << \" \"; // 输出：3 2 1}

3.3 const迭代器（只读访问）

用于遍历const vector（或需要保证元素不被修改的场景）：

• const_iterator：正向只读迭代器。
• const_reverse_iterator：反向只读迭代器。

例子：

const vector<int> cv = {1, 2, 3}; // const vector，元素不可修改for (vector<int>::const_iterator it = cv.begin(); it != cv.end(); ++it) { // *it = 10; // 错误！const迭代器不可修改元素 cout << *it << \" \"; // 输出：1 2 3}

4. 范围for循环（C++11起，最简洁）

语法：for (元素类型 变量 : vector名) { ... }
特点：自动遍历所有元素，无需手动控制索引或迭代器。
例子：

vector<int> v = {1, 2, 3};for (int num : v) { // 依次取v中的元素赋值给num cout << num << \" \"; // 输出：1 2 3}

修改元素：若需在范围for中修改元素，变量需用引用（&）：

vector<int> v = {1, 2, 3};for (int& num : v) { // 引用传递，可修改原元素 num *= 2;}for (int num : v) { cout << num << \" \"; // 输出：2 4 6}

总结：遍历方式对比

遍历方式 语法示例 优势 注意事项 下标访问 v[i] 直观，与数组一致 不检查越界，需确保 i < v.size() at()访问 v.at(i) 越界时抛出异常，更安全 性能略低于下标访问 迭代器遍历 for (auto it = v.begin(); ...) 支持STL算法（如sort），通用接口 注意迭代器失效问题 范围for循环 for (int num : v) 代码简洁，适合简单遍历 需C++11及以上标准

四、vector的容量管理

vector的容量管理与string类似，核心是区分大小（size） 和容量（capacity），并通过接口灵活控制内存。

1. size()：获取实际元素个数

作用：返回vector中当前元素的数量。
例子：

vector<int> v = {1, 2, 3};cout << v.size() << endl; // 输出：3

2. capacity()：获取当前分配的容量

作用：返回vector当前已分配的内存可容纳的最大元素数（容量 ≥ 大小）。
例子：

vector<int> v;v.push_back(1); // 添加一个元素cout << v.size() << endl; // 输出：1（实际元素数）cout << v.capacity() << endl; // 输出：1（初始容量，不同编译器可能不同）v.push_back(2); // 再次添加元素cout << v.capacity() << endl; // 输出：2（容量自动扩容）

3. empty()：判断是否为空

作用：检查vector是否不含任何元素（size() == 0）。
例子：

vector<int> v1;vector<int> v2 = {1};cout << v1.empty() << endl; // 输出：1（true，空）cout << v2.empty() << endl; // 输出：0（false，非空）

4. reserve(n)：预分配容量

作用：提前分配至少能容纳 n 个元素的内存（仅改变容量，不改变大小）。
目的：减少后续添加元素时的扩容次数（扩容需复制旧元素，代价高）。
例子：

vector<int> v;v.reserve(100); // 预分配100个元素的容量cout << v.size() << endl; // 输出：0（大小不变）cout << v.capacity() << endl; // 输出：100（容量变为100）

5. resize(n) / resize(n, val)：调整大小

作用：将vector的大小调整为 n：

• 若 n < 当前size()：截断多余元素（保留前 n 个）。
• 若 n > 当前size()：新增元素用 val 初始化（默认值：内置类型为0，自定义类型调用默认构造）。

例子：

vector<int> v = {1, 2, 3};v.resize(5, 10); // 大小扩至5，新增元素为10for (int num : v) { cout << num << \" \"; // 输出：1 2 3 10 10}v.resize(2); // 大小缩至2，截断多余元素for (int num : v) { cout << num << \" \"; // 输出：1 2}

6. shrink_to_fit()：释放多余内存

作用：将容量缩减至与大小相等，释放未使用的内存。
注意：需重新分配内存并复制元素，性能代价高，非必要不使用。
例子：

vector<int> v;v.reserve(100); // 容量100v.push_back(1); // 大小1，容量100v.shrink_to_fit(); // 容量缩减至1cout << v.capacity() << endl; // 输出：1

7. max_size()：理论最大容量

作用：返回vector在当前系统中可存储的最大元素数（受系统内存限制，实际很少用到）。
例子：

vector<int> v;cout << v.max_size() << endl; // 输出一个很大的数（如2^64/4）

总结：容量管理核心接口

接口 作用 关键区别 size() 实际元素个数 与“容量”无关 capacity() 已分配的最大容纳元素数 容量 ≥ 大小 reserve(n) 预分配容量（不改变大小） 仅影响容量，不初始化元素 resize(n) 调整大小（可能改变容量） 会初始化新增元素，可能截断元素 empty() 判断是否为空（size() == 0） 比 size() == 0 更简洁 shrink_to_fit() 释放多余内存（容量=大小） 性能代价高，谨慎使用

底层扩容机制（了解）

当vector的大小超过容量时，会自动扩容，通常遵循“翻倍策略”：

1. 申请一块大小为当前容量2倍（或1.5倍，取决于编译器）的新内存。
2. 将旧内存中的元素复制到新内存。
3. 释放旧内存，更新容量为新大小。

例子：

vector<int> v;// 初始容量：0v.push_back(1); // 容量变为1v.push_back(2); // 容量变为2（1*2）v.push_back(3); // 容量变为4（2*2）v.push_back(4); // 容量不变（4 ≥ 4）v.push_back(5); // 容量变为8（4*2）

五、vector的元素修改

vector提供了丰富的接口用于添加、删除、修改元素，以下是最常用的操作：

1. push_back()：尾部添加元素

作用：在vector末尾添加一个元素，若容量不足则自动扩容。
例子：

vector<int> v;v.push_back(1);v.push_back(2);for (int num : v) { cout << num << \" \"; // 输出：1 2}

2. pop_back()：尾部删除元素

作用：删除vector的最后一个元素，大小减1（容量不变）。
注意：不能对空vector使用（否则行为未定义）。
例子：

vector<int> v = {1, 2, 3};v.pop_back(); // 删除最后一个元素（3）for (int num : v) { cout << num << \" \"; // 输出：1 2}

3. insert()：指定位置插入元素

语法：insert(iterator pos, const T& val)
作用：在迭代器 pos 指向的位置插入元素 val，后续元素依次后移。
例子：

vector<int> v = {1, 2, 3};// 在第二个元素（2）前插入10v.insert(v.begin() + 1, 10);for (int num : v) { cout << num << \" \"; // 输出：1 10 2 3}

4. erase()：删除指定位置元素

语法：erase(iterator pos)
作用：删除迭代器 pos 指向的元素，后续元素依次前移，返回下一个有效迭代器。
例子：

vector<int> v = {1, 2, 3};// 删除第二个元素（2）v.erase(v.begin() + 1);for (int num : v) { cout << num << \" \"; // 输出：1 3}

5. swap()：交换两个vector

作用：交换两个vector的内容（元素、大小、容量），效率极高（仅交换指针）。
例子：

vector<int> v1 = {1, 2};vector<int> v2 = {3, 4, 5};v1.swap(v2); // 交换v1和v2for (int num : v1) cout << num << \" \"; // 输出：3 4 5for (int num : v2) cout << num << \" \"; // 输出：1 2

6. clear()：清空所有元素

作用：删除vector中的所有元素，大小变为0（容量不变）。
例子：

vector<int> v = {1, 2, 3};v.clear();cout << v.size() << endl; // 输出：0cout << v.capacity() << endl; // 输出：3（容量不变）

---

以上就是这篇博客的全部内容，下一篇我们将继续探索STL中vector的高级用法（如迭代器失效问题、与算法库结合等）。

我的个人主页，欢迎来阅读我的其他文章
https://blog.csdn.net/2402_83322742?spm=1011.2415.3001.5343
我的C++知识文章专栏
欢迎来阅读指出不足
https://blog.csdn.net/2402_83322742/category_12880513.html?spm=1001.2014.3001.5482

非常感谢您的阅读，喜欢的话记得三连哦