C++ vector核心用法与性能优化全解析

1. 为什么每个C++开发者都必须掌握vector

在C++标准库的所有容器中，vector可能是最容易被低估的一个。很多开发者把它简单地当作"动态数组"来使用，却不知道它背后隐藏着惊人的性能特性和使用技巧。我见过太多代码因为对vector理解不足而导致性能问题——比如有人在循环里频繁调用push_back导致多次内存重分配，或者错误使用erase导致迭代器失效。

vector本质上是一个封装了动态数组的模板类，它完美结合了数组的随机访问效率（O(1)时间复杂度）和动态扩容的灵活性。与原生数组相比，它自动管理内存，你不再需要手动计算容量；与链表结构相比，它的内存连续特性带来了极佳的空间局部性，这对现代CPU缓存机制特别友好。

关键认知：vector不是简单的"动态数组替代品"，而是经过精心设计的、在90%场景下都应该首选的默认容器选择。

2. vector核心接口全解析

2.1 基础构造与初始化

创建vector至少有5种标准方式，每种都有其适用场景：

cpp复制// 1. 空vector - 最常用基础构造
std::vector<int> v1;  

// 2. 预分配容量 - 知道大概元素数量时使用
std::vector<std::string> v2(100);  

// 3. 初始化列表 (C++11起)
std::vector<float> v3{1.1f, 2.2f, 3.3f};

// 4. 拷贝构造 - 深拷贝
std::vector<char> v4(v3.begin(), v3.end());

// 5. 移动构造 (C++11起) - 高效所有权转移
std::vector<double> v5(std::move(another_vector));

特别要注意的是初始化列表与圆括号构造的区别：

cpp复制std::vector<int> v{5};    // 1个元素，值为5
std::vector<int> v(5);    // 5个元素，值默认初始化为0

2.2 元素访问的陷阱与技巧

vector提供了多种访问元素的方式，但各有适用场景：

cpp复制std::vector<int> nums = {10, 20, 30};

// 1. operator[] - 最快但不安全
int a = nums[1];  // 20

// 2. at() - 安全但稍慢
try {
    int b = nums.at(5);  // 抛出std::out_of_range异常
} catch(...) {}

// 3. front()/back() - 首尾快捷访问
int first = nums.front(); // 10
int last = nums.back();   // 30

// 4. data() - 获取底层数组指针(C++11)
int* ptr = nums.data();  // 指向第一个元素

经验法则：在确定索引有效时用operator[]，不确定时用at()。debug模式下可以用at()捕获错误，release模式换回operator[]提升性能。

2.3 容量管理核心机制

vector最精妙的设计在于其容量(capacity)与大小(size)的分离管理：

cpp复制std::vector<int> vec;
vec.reserve(100);  // 预分配100个元素空间
cout << vec.size();      // 0 (当前元素数量)
cout << vec.capacity();  // 100 (当前总容量)

for(int i=0; i<50; ++i) {
    vec.push_back(i);    // 不会触发重分配
}

扩容策略通常是当前容量的1.5或2倍（实现依赖），这解释了为什么反复push_back时性能不是线性下降。实测表明，在MSVC中扩容因子是1.5，而GCC是2。

2.4 元素操作高级技巧

高效插入

cpp复制std::vector<int> v = {1, 2, 4, 5};
auto it = v.begin() + 2;
v.insert(it, 3);  // 在位置2插入3 → {1,2,3,4,5}

插入操作的时间复杂度是O(n)，因为需要移动后续元素。如果要在开头频繁插入，考虑使用deque。

安全删除

cpp复制std::vector<int> v = {1, 2, 3, 4, 5};

// 删除单个元素
v.erase(v.begin() + 2);  // 删除3 → {1,2,4,5}

// 删除范围
v.erase(v.begin(), v.begin()+2); // 删除前两个 → {4,5}

// erase-remove惯用法
v = {1, 2, 3, 2, 4};
v.erase(std::remove(v.begin(), v.end(), 2), v.end()); // 删除所有2 → {1,3,4}

关键陷阱：erase会使被删除位置之后的迭代器失效！循环中删除元素必须特别小心：

cpp复制// 错误示范！
for(auto it = v.begin(); it != v.end(); ++it) {
    if(*it % 2 == 0) {
        v.erase(it);  // it失效，下次++会出错
    }
}

// 正确写法
for(auto it = v.begin(); it != v.end(); ) {
    if(*it % 2 == 0) {
        it = v.erase(it);  // erase返回下一个有效迭代器
    } else {
        ++it;
    }
}

3. 性能优化实战策略

3.1 预分配的正确姿势

通过reserve()预分配内存可以避免多次扩容，但要注意：

cpp复制std::vector<int> v;
v.reserve(1000);  // 一次性分配足够空间

// 错误用法：reserve后size仍为0，直接使用operator[]会越界
v[0] = 1;  // 未定义行为！

// 正确做法：使用push_back或resize
for(int i=0; i<1000; ++i) {
    v.push_back(i);  // 不会触发重分配
}

3.2 移动语义的应用

C++11的移动语义让vector操作更高效：

cpp复制std::vector<std::string> createStrings() {
    std::vector<std::string> tmp;
    // ...填充数据...
    return tmp;  // 触发移动构造而非拷贝
}

std::vector<std::string> v = createStrings();  // 零拷贝

对于大型对象，使用emplace_back避免临时对象：

cpp复制struct Person {
    Person(std::string n, int a) : name(n), age(a) {}
    std::string name;
    int age;
};

std::vector<Person> people;
people.emplace_back("Alice", 30);  // 直接在容器内构造

3.3 内存收缩技巧

vector不会自动缩小容量，需要特殊处理：

cpp复制std::vector<int> v(1000);
v.erase(v.begin()+100, v.end());  // size=100, capacity仍为1000

// 方法1：swap惯用法 (C++11前)
std::vector<int>(v).swap(v);  // capacity变为100

// 方法2：shrink_to_fit (C++11)
v.shrink_to_fit();  // 请求缩小容量

注意：shrink_to_fit只是请求，不保证一定会缩小。

4. 多维vector实战

4.1 二维vector的声明与初始化

cpp复制// 方法1：逐个push_back
std::vector<std::vector<int>> matrix1;
for(int i=0; i<rows; ++i) {
    matrix1.push_back(std::vector<int>(cols, 0));
}

// 方法2：一次性构造 (C++11)
std::vector<std::vector<int>> matrix2(rows, std::vector<int>(cols));

// 方法3：初始化列表 (C++11)
std::vector<std::vector<int>> matrix3 = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

4.2 高效遍历多维vector

行优先遍历（缓存友好）：

cpp复制for(size_t i=0; i<matrix.size(); ++i) {
    for(size_t j=0; j<matrix[i].size(); ++j) {
        matrix[i][j] = i + j;
    }
}

使用范围for循环(C++11)：

cpp复制for(auto& row : matrix) {
    for(auto& elem : row) {
        elem *= 2;
    }
}

5. 类型安全与异常处理

5.1 安全访问模式

cpp复制template<typename T>
T safeGet(const std::vector<T>& v, size_t index, T defaultValue = T()) {
    return (index < v.size()) ? v[index] : defaultValue;
}

5.2 异常安全保证

vector提供以下异常安全保证：

• push_back/emplace_back：强保证（操作失败时容器状态不变）
• insert/emplace：基本保证（操作失败时容器仍有效）
• erase：不抛出异常
• swap：不抛出异常

6. 实际工程中的经验教训

6.1 迭代器失效的典型场景

cpp复制std::vector<int> v = {1, 2, 3, 4, 5};
auto it = v.begin() + 2;

v.push_back(6);  // 可能导致重分配，所有迭代器失效！
*it = 10;        // 未定义行为！

解决方案：

1. 在修改操作后重新获取迭代器
2. 使用索引代替迭代器
3. 预先reserve足够空间

6.2 自定义分配器的使用

cpp复制template<typename T>
class DebugAllocator : public std::allocator<T> {
public:
    T* allocate(size_t n) {
        std::cout << "Allocating " << n << " elements\n";
        return std::allocator<T>::allocate(n);
    }
    // ...其他成员函数...
};

std::vector<int, DebugAllocator<int>> v;
v.reserve(10);  // 输出分配信息

6.3 与其他容器的性能对比

选择原则：

• 需要频繁随机访问 → vector
• 需要频繁头尾插入 → deque
• 需要频繁中间插入 → list

7. C++17/20新特性应用

7.1 emplace_back返回值 (C++17)

cpp复制std::vector<std::pair<int, std::string>> v;
auto& elem = v.emplace_back(1, "test");  // 直接返回引用
elem.second = "modified";

7.2 constexpr vector (C++20)

cpp复制constexpr std::vector<int> createVector() {
    std::vector<int> v{1, 2, 3};
    v.push_back(4);
    return v;
}

constexpr auto cv = createVector();  // 编译期构造

8. 性能测试与调优案例

8.1 reserve vs 无reserve对比测试

cpp复制#include <chrono>
#include <vector>

void testPerformance() {
    const int COUNT = 1000000;
    
    // 无reserve
    auto start1 = std::chrono::high_resolution_clock::now();
    std::vector<int> v1;
    for(int i=0; i<COUNT; ++i) {
        v1.push_back(i);
    }
    auto end1 = std::chrono::high_resolution_clock::now();
    
    // 有reserve
    auto start2 = std::chrono::high_resolution_clock::now();
    std::vector<int> v2;
    v2.reserve(COUNT);
    for(int i=0; i<COUNT; ++i) {
        v2.push_back(i);
    }
    auto end2 = std::chrono::high_resolution_clock::now();
    
    // 输出结果
    auto dur1 = std::chrono::duration_cast<std::chrono::milliseconds>(end1-start1);
    auto dur2 = std::chrono::duration_cast<std::chrono::milliseconds>(end2-start2);
    std::cout << "Without reserve: " << dur1.count() << "ms\n";
    std::cout << "With reserve: " << dur2.count() << "ms\n";
}

典型结果：

code复制Without reserve: 23ms
With reserve: 8ms

8.2 元素类型对性能的影响

测试不同元素类型对vector性能的影响：

结论：vector对小型POD类型性能最佳，复杂对象建议存储指针或使用专门优化过的容器。