在C++编程中，vector 是标准模板库（STL）中最常用的容器之一。它以其动态数组的特性、高效的尾部操作和便捷的随机访问能力，成为处理动态数据的首选工具。无论是初学者还是经验丰富的开发者，掌握 vector 的使用方法和性能优化技巧，都是提升代码效率的关键。

        然而，vector 的强大功能背后也隐藏着一些需要注意的细节，例如动态扩容的开销、迭代器失效问题以及不同操作的性能差异。

一、vector 容器概述

• 定义：vector 是C++标准模板库（STL）中的动态数组，支持随机访问、动态扩容和高效尾部操作。

• 特点：

  • 内存连续存储，支持快速随机访问（时间复杂度 O(1)）。

  • 尾部插入/删除高效（均摊 O(1)），中间或头部操作效率较低（O(n)）。

  • 自动管理内存，动态调整容量（通过 reserve 可手动优化）。

---

二、vector 常用操作及示例

1. 构造函数与初始化

操作	功能说明	示例代码
默认构造	创建空 vector	vector<int> v1;
指定大小和初始值	创建大小为 n 的 vector	vector<int> v2(5, 10); // 5个元素，值10
通过迭代器初始化	用其他容器的范围初始化	vector<int> v3(v2.begin(), v2.end());
列表初始化（C++11）	直接通过列表初始化	vector<int> v4 = {1, 2, 3, 4};

---

2. 元素访问

操作	功能说明	示例代码	时间复杂度
v[i]	访问第 i 个元素（不检查越界）	int x = v[2];	O(1)
v.at(i)	访问第 i 个元素（检查越界）	int y = v.at(3); // 越界抛出异常	O(1)
v.front()	访问第一个元素	int first = v.front();	O(1)
v.back()	访问最后一个元素	int last = v.back();	O(1)
v.data()	获取底层数组指针	int* p = v.data();	O(1)

---

3. 容量操作

操作	功能说明	示例代码	时间复杂度
v.empty()	判断容器是否为空	if (v.empty()) { ... }	O(1)
v.size()	返回元素个数	int n = v.size();	O(1)
v.capacity()	返回当前分配的容量	int cap = v.capacity();	O(1)
v.reserve(n)	预分配容量（避免多次扩容）	v.reserve(100);	O(n)
v.shrink_to_fit()	请求释放未使用的内存	v.shrink_to_fit();	O(n)

---

4. 修改操作

操作	功能说明	示例代码	时间复杂度
v.push_back(val)	在尾部插入元素	v.push_back(10);	均摊 O(1)
v.pop_back()	删除尾部元素	v.pop_back();	O(1)
v.insert(pos, val)	在 pos 位置插入元素	v.insert(v.begin() + 2, 20);	O(n)
v.erase(pos)	删除 pos 位置的元素	v.erase(v.begin() + 1);	O(n)
v.clear()	清空所有元素	v.clear();	O(n)
v.resize(n)	调整容器大小为 n	v.resize(10); // 新元素默认初始化	O(n)
v.emplace_back(args)	在尾部直接构造元素（避免拷贝）	v.emplace_back(10);	均摊 O(1)

---

5. 遍历操作

操作	功能说明	示例代码
范围for循环（C++11）	遍历所有元素	for (int x : v) { cout << x << " "; }
迭代器遍历	使用迭代器遍历	for (auto it = v.begin(); it != v.end(); ++it) { ... }

---

三、代码示例

1. 基本操作示例

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // 初始化
    vector<int> vec = {1, 2, 3, 4, 5};

    // 尾部插入元素
    vec.push_back(6);          // vec: {1, 2, 3, 4, 5, 6}

    // 访问元素
    cout << "Third element: " << vec[2] << endl;  // 输出: 3
    cout << "Last element: " << vec.back() << endl; // 输出: 6

    // 删除尾部元素
    vec.pop_back();            // vec: {1, 2, 3, 4, 5}

    // 插入元素
    vec.insert(vec.begin() + 2, 10); // vec: {1, 2, 10, 3, 4, 5}

    // 删除元素
    vec.erase(vec.begin() + 3);      // vec: {1, 2, 10, 4, 5}

    // 遍历输出
    for (int x : vec) {
        cout << x << " ";       // 输出: 1 2 10 4 5
    }

    return 0;
}

2. 容量管理示例

#include <vector>
#include <iostream>
using namespace std;

int main() {
    vector<int> vec;
    cout << "Initial capacity: " << vec.capacity() << endl; // 输出: 0

    vec.reserve(5);  // 预分配容量为5
    for (int i = 0; i < 10; ++i) {
        vec.push_back(i);
        cout << "Size: " << vec.size() 
             << ", Capacity: " << vec.capacity() << endl;
    }
    // 容量会自动扩展（具体策略依赖实现，如翻倍扩容）

    vec.shrink_to_fit(); // 释放多余内存
    return 0;
}

3.更多例子

#include <bits/stdc++.h>  // 包含标准库的所有头文件
using namespace std;       // 使用标准命名空间

int main() {              // 主函数开始
    vector<int> a;        // 初始化一个 size 为 0 的 vector
    a.insert(a.begin(), 4, 2);  // 在 a 的开始位置插入 4 个值为 2 的元素

    // 下面的 4 个 for 是 4 种遍历方法
    for (int i = 0; i < a.size(); i++)  // 通过下标访问，输出 2 2 2 2
        cout << a[i] << " "; cout << "\n";  // 输出每个元素

    for (vector<int>::iterator it = a.begin(); it != a.end(); ++it)  // 通过迭代器访问
        cout << *it << " "; cout << "\n";  // 输出每个元素

    for (auto it = a.begin(); it != a.end(); ++it)  // 用 auto 获得迭代器
        cout << *it << " "; cout << "\n";  // 输出每个元素

    for (auto i : a)  // 直接访问 vector 中的每个元素
        cout << i << " "; cout << "\n";  // 输出每个元素

    a.insert(a.begin() + 1, 9);  // 在 a[1] 处插入 9, a = {2 9 2 2 2}
    a.insert(a.begin() + 2, 2, 5);  // 在 a[2] 处插入两个 5, a = {2 9 5 5 2 2 2}
    a.resize(3);  // 改变 a 的大小为 3, a = {2 9 5}

    vector<int> c(a);  // 复制 a 到 c
    vector<int> b;     // 初始化一个空的 vector b
    b.insert(b.begin(), a.begin(), a.begin() + 3);  // 将 a 的前 3 个数复制到 b

    // 下面演示二维 vector
    vector<vector<char>> ch(2, vector<char>(3, '#'));  // 初始化一个 2 行 3 列的二维 vector，所有元素为 '#'
    for (int i = 0; i < 2; i++) {  // 遍历行
        for (int j = 0; j < 3; j++)  // 遍历列
            cout << ch[i][j];  // 输出每个元素
        cout << "\n";
    }

    // 下面演示用 vector 存储物体
    struct point { int x, y; };  // 定义一个结构体 point，包含两个整型成员 x 和 y
    vector<point> PP;  // 初始化一个存储 point 结构体的 vector
    for (int i = 0; i < 3; i++) {  // 循环 3 次
        point t; t.x = i; t.y = i;  // 创建一个 point 对象 t，并赋值
        PP.push_back(t);  // 将 t 添加到 PP 中
    }

    for (int i = 0; i < PP.size(); i++)  // 遍历 PP
        cout << PP[i].x << " " << PP[i].y << "\n";  // 输出每个 point 的 x 和 y

    auto it = PP.begin();  // 获取 PP 的起始迭代器
    for (; it != PP.end(); ++it)  // 使用迭代器遍历 PP
        cout << it->x << " " << it->y << "\n";  // 输出每个 point 的 x 和 y

    return 0;  // 主函数结束
}

---

四、总结

1. 优点：

   • 快速随机访问（通过下标或迭代器）。

   • 尾部插入/删除高效。

   • 内存自动管理，支持动态扩容。

2. 缺点：

   • 中间或头部插入/删除效率低（需移动元素）。

   • 频繁扩容可能影响性能（可通过 reserve 优化）。

3. 适用场景：

   • 需要频繁随机访问元素。

   • 尾部操作较多，中间操作较少。