【C++】std::vector的用法详解

一、底层原理与内存模型​

1. 动态数组实现

• ​连续内存块​：所有元素存储在连续内存中，支持指针算术运算
• ​三指针结构​（典型实现）：

  _Myfirst  // 指向首元素
  _Mylast   // 指向最后一个有效元素的下一个位置
  _Myend    // 指向预分配内存的末尾

• ​扩容机制​：当size() == capacity()时触发，VS默认扩容1.5倍，GCC为2倍

2. 内存操作可视化

vector<int> v = {1,2,3};
v.push_back(4);  // 触发扩容（假设原容量为3）

// 内存变化：
// 旧地址: [1][2][3] → 容量3
// 新地址: [1][2][3][4][ ][ ] → 容量6（假设GCC扩容策略）

---

​二、核心操作全解​

1. 构造与赋值

// 移动构造（C++11）
vector<string> v1 = {"a", "b", "c"};
vector<string> v2(std::move(v1));  // v1变为空，v2接管资源

// 范围赋值
vector<int> src{1,3,5,7};
vector<int> dst;
dst.assign(src.begin()+1, src.end());  // dst = {3,5,7}

2. 元素访问的底层解析

// operator[] vs at()
vector<int> v(10);
v[5] = 100;      // 直接指针偏移：*(_Myfirst + 5) = 100
v.at(10) = 200;  // 检查边界：if (10 >= size()) throw out_of_range

3. 迭代器失效场景

操作	失效范围	解决方案
push_back	所有迭代器可能失效	重新获取end()迭代器
insert	插入点之后的迭代器	使用返回值更新迭代器
erase	被删元素之后的迭代器	使用erase返回的新迭代器
reserve	全部迭代器可能失效	操作后重新获取所有迭代器

---

​三、性能优化策略​

1. 元素构造优化

class HeavyObject {
public:
    HeavyObject(int id, const string& name) {...}
};

vector<HeavyObject> objs;

// 传统方式（产生临时对象）
objs.push_back(HeavyObject(1, "obj1"));  

// 优化方式（直接构造）
objs.emplace_back(1, "obj1");  // 避免拷贝/移动

2. 批量操作优化

// 高效合并两个vector（C++11）
vector<int> a(1000000, 1);
vector<int> b(1000000, 2);

a.insert(a.end(), 
         std::make_move_iterator(b.begin()),
         std::make_move_iterator(b.end()));  // 移动而非拷贝

3. 内存回收技巧

vector<int> bigVec(1000000);

// 正确释放内存方式
vector<int>().swap(bigVec);  // C++03
bigVec.shrink_to_fit();      // C++11（配合clear使用）

---

​四、高级应用场景​

1. 自定义分配器

#include <memory_resource>  // C++17

// 使用栈内存作为存储
char buffer[4096];
std::pmr::monotonic_buffer_resource pool{std::data(buffer), std::size(buffer)};
std::pmr::vector<int> vec{&pool};

for(int i=0; i<1000; ++i) {
    vec.push_back(i);  // 使用预分配的栈内存
}

2. 多维数组处理

// 3D矩阵（10x20x30）
vector<vector<vector<float>>> matrix(
    10, vector<vector<float>>(
        20, vector<float>(30, 0.0f)
    )
);

// 扁平化存储优化（提升缓存利用率）
vector<float> flatMatrix(10 * 20 * 30);
auto get = [&](int x, int y, int z) {
    return flatMatrix[x*20 * 30 + y*30 + z];
};

3. 类型擦除存储

#include <any>  // C++17

vector<any> heterogeneous;
heterogeneous.push_back(42);
heterogeneous.push_back("hello");
heterogeneous.push_back(3.14);

// 类型安全访问
try {
    int val = any_cast<int>(heterogeneous[0]);
} catch(const bad_any_cast& e) {
    cerr << e.what() << endl;
}

---

​五、与其他容器的协同​

1. 与字符串的转换

// vector<char> 转 string
vector<char> chars{'H', 'e', 'l', 'l', 'o'};
string s(chars.begin(), chars.end());

// string 转 vector<uint8_t>
string data = "binary";
vector<uint8_t> binary(data.begin(), data.end());

2. 与数组的交互

// C风格数组转vector
int arr[] = {1,3,5};
vector<int> vec(arr, arr + sizeof(arr)/sizeof(arr[0]));

// vector数据暴露给C接口
extern void process(int* arr, size_t len);
vector<int> data = getData();
process(data.data(), data.size());  // C++11起data()返回指针

---

​六、调试与性能分析​

1. 内存布局检查

vector<int> v{1,2,3,4,5};

cout << "元素地址连续性验证：\n";
for(auto& elem : v) {
    cout << &elem << endl;  // 相邻地址差应为sizeof(int)
}

2. 性能分析指标

vector<int> v;
v.reserve(1000000);

auto start = chrono::high_resolution_clock::now();
for(int i=0; i<1000000; ++i) {
    v.push_back(i);  // 测试插入耗时
}
auto end = chrono::high_resolution_clock::now();

cout << "单元素插入耗时：" 
     << chrono::duration_cast<chrono::nanoseconds>(end-start).count()/1e6
     << " ns/op\n";

---

​七、最佳实践总结​

1. ​容量预判原则​：在已知元素数量时优先使用reserve()
2. ​元素访问准则​：
   • 只读操作使用const auto&
   • 修改操作使用auto&
3. ​异常安全策略​：

   vector<FileHandler> files;
   files.push_back(FileHandler("a.txt"));  // 可能抛出异常
   // 使用emplace_back+try或RAII包装器

4. ​跨API交互规范​：

   // 导出到DLL接口
   extern "C" __declspec(dllexport) void ProcessData(
       const int* data, size_t len) {
       vector<int> localData(data, data+len);
       // 处理数据
   }

---

掌握这些深度技巧后，您将能够：

• 在内存敏感场景优化vector性能
• 安全处理大规模数据集合
• 实现复杂数据结构的高效操作
• 避免90%以上的常见陷阱