C++ STL 容器 vector 详解：定义、访问与操作

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};
    std::cout << "原始 vector：";
    for (int& val : vec) std::cout << val << " ";
    std::cout << "\n=== at() 安全访问 ===" << std::endl;

    // 1. 读取元素
    std::cout << "索引 2 的元素：" << vec.at(2) << std::endl; // 输出 30

    // 2. 修改元素（返回引用，支持读写）
    vec.at(3) = 400; // 将索引 3 的元素从 40 改为 400
    std::cout << "修改后 vector：";
    for (int& val : vec) std::cout << val << " ";
    std::cout << std::endl;

    // 3. 越界访问（抛出异常，可捕获）
    try {
        vec.at(10); // 索引 10 超出范围，抛出异常
    } catch (const std::out_of_range& e) {
        std::cout << "at() 越界错误：" << e.what() << std::endl;
    }
}

2.2 operator[] 访问

[] 下标运算符最常用，效率最高。

• 语法：vec[index]（索引从 0 开始）
• 特点：直接内存访问，执行效率最佳；但不进行边界检查，越界访问可能引发未定义行为（程序崩溃或内存污染）。

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};
    std::cout << "原始 vector：";
    for (int& val : vec) std::cout << val << " ";
    std::cout << "\n=== [] 下标访问 ===" << std::endl;

    // 1. 读取元素
    std::cout << "索引 0 的元素：" << vec[0] << std::endl; // 输出 10
    std::cout << "索引 3 的元素：" << vec[3] << std::endl; // 输出 40

    // 2. 修改元素（返回引用，支持读写）
    vec[1] = 200; // 将索引 1 的元素从 20 改为 200
    vec[4] = 500; // 将索引 4 的元素从 50 改为 500
    std::cout << "修改后 vector：";
    for (int val : vec) std::cout << val << " ";
    std::cout << std::endl;

    // 3. 注意：越界访问（危险！未定义行为）
    // vec[10] = 999; // 索引 10 超出范围（0~4），可能崩溃，编译器不报错
}

2.3 迭代器访问

2.3.1 普通迭代器

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};
    std::cout << "原始 vector：";
    for (int& val : vec) std::cout << val << " ";
    std::cout << "\n=== 普通迭代器（可读写） ===" << std::endl;

    std::vector<int>::iterator it = vec.begin(); // it 指向第一个元素（10）
    for (; it != vec.end(); ++it) {
        std::cout << *it << std::endl;
    }
    std::cout << std::endl;

    it = vec.begin();
    for (; it != vec.end(); ++it) {
        *it += 10;
        std::cout << *it << std::endl;
    }
    return 0;
}

2.3.2 常性迭代器

只可读元素，不可以修改值。

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};
    std::cout << "原始 vector：";
    for (int& val : vec) std::cout << val << " ";
    std::cout << "\nconst 迭代器遍历（只读）：" << std::endl;

    std::vector<int>::const_iterator cit = vec.cbegin(); // cbegin() 返回 const 迭代器
    for (; cit != vec.cend(); ++cit) {
        std::cout << *cit << " "; // 正常读取
        // *cit = 0; // 编译错误：const 迭代器禁止修改元素
    }
    std::cout << std::endl;
    return 0;
}

2.3.3 逆置迭代器

使用 rbegin() 和 rend() 可以获取反向迭代器，用于从后向前遍历。

2.4 at 和 operator[] 的区别

• at() 安全但稍慢，适合需要边界检查的场景。
• [] 快速但不安全，适合已知索引合法的高频场景。

3. 插入元素到 vector

3.1 push_back

向尾部插入元素。若插入前没有可用空间，需先扩容（通常原容量的 1.5 倍~2 倍），并将原数组所有元素拷贝/移动到新的内存。

• 拷贝构造：创建临时副本对象，通过定位 new 构造在 vector 空间。
• 移动构造：将对象资源直接转移到 vector 空间。

建议在使用 push_back 前调用 reserve 预留空间，避免频繁扩容。

3.2 emplace_back

解决频繁拷贝和移动资源的问题，又称原位构造。直接在 vector 空间上构造对象，避免临时对象的创建。

3.3 insert

在指定位置插入元素。

// 插入单个元素
iterator insert(iterator pos, const T& value);
iterator insert(iterator pos, T&& value); // C++11 移动语义

// 插入多个相同元素
iterator insert(iterator pos, size_t count, const T& value);

// 插入元素区间
template <class InputIt>
iterator insert(iterator pos, InputIt first, InputIt last);

3.4 emplace_back 和 push_back 区别

• push_back：先构造临时对象，再移动/拷贝进容器。
• emplace_back：直接将参数传递给构造函数，原地构造。

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

class Person {
public:
    Person(string name, int age) : name_(name), age_(age) {}
private:
    string name_;
    int age_;
};

int main() {
    vector<Person> v;
    // push_back：先构造临时 Person，再移动到 vector
    v.push_back(Person("Alice", 20));
    // emplace_back：直接在 vector 尾部原地构造 Person
    v.emplace_back("Bob", 22);
    return 0;
}

4. reserve 和 resize

• reserve(n)：预分配至少 n 个元素的存储空间，不改变 size，仅增加 capacity。
• resize(n)：改变容器大小。若新大小大于当前大小，新增元素默认初始化；若小于，则销毁多余元素。

vector<int> vec{1, 2, 3};
vec.reserve(10);
std::cout << vec.size();   // 输出 3（元素数量不变）
std::cout << vec.capacity(); // 输出 10（内存已预分配）

vector<int> vec2{1, 2, 3};
vec2.resize(5); // 新增 2 个元素，默认值为 0 → vec = {1, 2, 3, 0, 0}
std::cout << vec2.size();   // 输出 5
std::cout << vec2.capacity(); // 输出 ≥5

vec2.resize(2); // 销毁后 3 个元素 → vec = {1, 2}
std::cout << vec2.size();   // 输出 2

5. assign

assign() 用于替换容器中的所有现有元素（先清空原有元素，再插入新元素）。它会直接改变 vector 的 size，并在新元素数量超过当前容量时调整 capacity。

形式 1：assign(n, val)

vector<int> vec{1, 2, 3}; // 原内容：{1, 2, 3}
vec.assign(4, 10);        // 清空原元素 → 插入 4 个 10
// 结果：vec = {10, 10, 10, 10}，size=4，capacity≥4

形式 2：assign(first, last)

vector<int> vec{1, 2, 3};
int arr[] = {100, 200, 300, 400};
vec.assign(arr + 1, arr + 3); // 插入数组中 arr+1 到 arr+3 的元素（200、300）
// 结果：vec = {200, 300}

vector<int> tmp{5, 6, 7};
vec.assign(tmp.begin(), tmp.end()); // 从另一个 vector 导入
// 结果：vec = {5, 6, 7}

形式 3：assign(initializer_list)

vector<int> vec{1, 2, 3};
vec.assign({8, 9, 10, 11}); // 清空原元素 → 插入 8、9、10、11
// 结果：vec = {8, 9, 10, 11}，size=4，capacity≥4

特殊情况

• 内存变化：自动扩容（当新元素数量 > 当前 capacity），不会主动缩容（如原 capacity=10，assign(2, 0) 后 capacity 仍为 10）。
• 元素析构：对于类对象，assign() 会先调用所有原有元素的析构函数，再构造新元素。
• n=0 时：assign(0, val) 等价于清空 vector（size=0），但 capacity 不变（需使用 shrink_to_fit() 释放内存）。

vec.assign(0, 0); // 清空所有元素，size=0，capacity 不变

6. 迭代器失效

6.1 迭代器失效本质

迭代器本质是'容器元素的内存指针 / 索引封装'。当容器底层内存布局改变（如扩容、元素移动）、元素被删除时，迭代器指向的地址 / 逻辑位置失效，此时解引用或操作迭代器会导致 UB（未定义行为）。

6.2 迭代器失效场景

• 对 vector 进行插入操作（push_back, insert）可能导致扩容，使所有迭代器失效。
• 对 vector 进行删除操作（erase）导致元素移动，使被删除位置及之后的迭代器失效。
• 对 vector 进行 resize 操作可能导致内存重新分配，使所有迭代器失效。