吃透 C++ vector：从基础使用到核心接口实战指南

吃透 C++ std::vector：从基础使用到核心接口实战指南（2025–2026 视角）

std::vector 是 C++ 中使用最广泛的动态数组容器，几乎所有现代 C++ 代码都会用到它。掌握它不仅是入门要求，更是写出高效、安全、可维护代码的关键。

本文从零基础到高级用法全面覆盖，包含常见陷阱、最佳实践、C++11/14/17/20/23 新特性，以及真实场景写法对比。

1. 为什么 vector 是“默认选择”？

• 连续内存 → 极佳的缓存友好性（cache locality）
• 随机访问 O(1)
• 尾部增删很快（amortized O(1)）
• 自动管理内存（RAII）
• 相比 array / list / deque 在大多数场景下性能最好

何时不选 vector？

• 频繁中间插入/删除 → 用 std::list 或 std::deque
• 需要严格固定大小 → 用 std::array
• 需要非连续内存 + 频繁插入 → 用 std::deque

2. 基础用法（你必须熟练）

#include <vector>
#include <iostream>
#include <string>

int main() {
    // 1. 声明与初始化
    std::vector<int> v1;                    // 空 vector
    std::vector<int> v2(10);                // 10 个 0
    std::vector<int> v3(10, 42);            // 10 个 42
    std::vector<int> v4 = {1, 2, 3, 4, 5};  // 初始化列表（最常用）
    std::vector<std::string> names{"Alice", "Bob", "Charlie"};

    // 2. 常用成员函数
    std::cout << "size: " << v4.size() << '\n';      // 5
    std::cout << "capacity: " << v4.capacity() << '\n';
    std::cout << "empty? " << v4.empty() << '\n';    // 0

    v4.push_back(6);          // 尾插
    v4.pop_back();            // 尾删
    v4.front() = 10;          // 访问第一个元素（无边界检查）
    v4.back() = 20;           // 最后一个
    v4[2] = 99;               // 随机访问（无边界检查）
    v4.at(2) = 100;           // 有边界检查，异常安全

    // 3. 遍历（现代写法优先）
    for (int x : v4) {                  // 推荐：值拷贝（小类型）
        std::cout << x << ' ';
    }

    for (const auto& x : v4) {          // 推荐：大对象/不可拷贝
        // ...
    }

    // C++17 结构化绑定 + if initializer
    if (auto it = v4.begin(); it != v4.end()) {
        std::cout << *it << '\n';
    }
}

3. 性能关键：capacity vs size 与 reserve

size = 当前元素个数
capacity = 已分配内存能容纳的元素个数（≥ size）

最重要性能陷阱：不提前 reserve 导致反复重新分配（reallocation）

std::vector<int> v;

// 坏：可能引发多次 realloc + 元素移动
for (int i = 0; i < 1'000'000; ++i) {
    v.push_back(i);
}

// 好：知道大概规模就 reserve
v.reserve(1'000'000);   // 一次分配到位，后续 push_back 极快
for (int i = 0; i < 1'000'000; ++i) {
    v.push_back(i);
}

shrink_to_fit()（C++11）：请求释放多余容量（不保证一定释放）

v.shrink_to_fit();  // size 很大但 capacity 远大于 size 时用

4. push_back vs emplace_back（性能分水岭）

struct Widget {
    std::string name;
    int id;
    double value;

    Widget(std::string n, int i, double v) 
        : name(std::move(n)), id(i), value(v) {}
};

// 较差
v.push_back(Widget("sensor1", 42, 3.14));     // 构造临时对象 → 移动/拷贝

// 更好（C++11+ 强烈推荐）
v.emplace_back("sensor2", 100, 2.718);        // 直接在 vector 内存里构造，无临时对象

经验法则：

• 能用 emplace_back 就用（尤其是非 trivial 类型）
• 只在需要拷贝已有对象时才用 push_back(std::move(x))

5. 插入 / 删除（erase / insert 的陷阱）

经典错误：边遍历边 erase → 迭代器失效

// 错误写法
for (auto it = v.begin(); it != v.end(); ++it) {
    if (*it % 2 == 0) v.erase(it);   // 失效！下一行崩溃或 UB
}

正确写法（三种）

// 1. erase 返回下一个有效迭代器（最常用）
auto it = v.begin();
while (it != v.end()) {
    if (*it % 2 == 0) {
        it = v.erase(it);
    } else {
        ++it;
    }
}

// 2. erase-remove idiom（推荐，简洁）
v.erase(std::remove_if(v.begin(), v.end(), 
                       [](int x){ return x % 2 == 0; }), 
        v.end());

// 3. C++20 一步到位（最优雅）
std::erase_if(v, [](int x){ return x % 2 == 0; });

insert 同样昂贵（移动后续元素），尽量用 emplace 版本。

6. 迭代器失效规则（必须记住）

操作	迭代器 / 引用 / 指针失效情况
push_back / emplace_back	capacity 不够时 → 全部失效
reserve	不失效（只增加 capacity）
insert / emplace	插入点之后全部失效
erase	被删除元素及之后全部失效
pop_back	仅最后一个元素失效，其余不变
clear / resize	全部失效
shrink_to_fit	可能失效（实现依赖）

安全策略：

• 需要长期持有迭代器 → 用索引或 std::distance
• 频繁修改 → 考虑 std::deque 或 std::list

7. 现代 C++ 中的 vector 最佳实践（2025+）

// 1. 优先范围构造 / 范围 for
std::vector<int> src = ...;
std::vector<int> dest(src.begin(), src.end());   // 或直接 = src

// 2. C++20 ranges + erase_if
#include <ranges>
auto even = v | std::views::filter([](int x){ return x % 2 == 0; });
std::vector<int> evens(even.begin(), even.end());

// 3. 移动语义优化大 vector
std::vector<LargeObject> heavy = ...;
std::vector<LargeObject> backup = std::move(heavy);  // 廉价转移

// 4. 避免不必要的拷贝
void process(const std::vector<int>& data);          // 引用传递

8. 常见性能 / 安全陷阱汇总

陷阱	后果	解决方案
不 reserve 就大量 push_back	多次 realloc + 移动	提前 reserve
循环中 erase(it++)	迭代器失效 → UB	用 erase 返回值 / erase-remove
用 [] 越界	UB（无声崩溃）	用 .at()
长期持有迭代器 + push_back	迭代器失效	用索引或重新获取 begin/end
大对象频繁 push_back 而非 emplace	多余拷贝/移动	用 emplace_back
clear() 后 capacity 仍很大	内存浪费	shrink_to_fit()

9. 小结：vector 使用口诀（2025 版）

• 知道大小提前 reserve
• 构造对象直接 emplace_back
• 删除用 erase_if / erase-remove
• 遍历优先 const auto&
• 边界检查用 .at()
• 大 vector 移动而非拷贝
• C++20+ 直接 std::erase_if

如果你能熟练避开上面陷阱，写出带 reserve + emplace + erase_if 的代码，你的 vector 水平已经超过 80% 的开发者了。

有具体场景（比如百万级数据处理、多线程 vector、vector of move-only 类型等）想深入探讨吗？欢迎贴代码或描述需求，我帮你给出最优写法。