数据结构手册002：动态数组vector - 连续内存的艺术与科学
从静态到动态：为什么需要vector？
在C++的世界里，数组是最基础的数据结构，但原生数组有着天生的局限性：
cpp
// 原生数组的痛点
int arr[100]; // 大小必须在编译期确定
// int arr[n]; // 错误！n必须是常量
// 内存浪费或不足的风险
int scores[1000]; // 如果只有50个学生，浪费950个位置
// 如果来了1001个学生，数组越界！这就是std::vector登场的背景------一个能够动态调整大小的智能数组。
vector的底层奥秘：三指针架构
理解vector的关键在于掌握其内部实现。一个典型的vector包含三个核心指针：
cpp
template<typename T>
class SimplifiedVector {
private:
T* start_; // 指向内存块起始位置
T* finish_; // 指向最后一个元素的下一个位置
T* end_of_storage_; // 指向内存块的结束位置
public:
size_t size() const { return finish_ - start_; }
size_t capacity() const { return end_of_storage_ - start_; }
bool empty() const { return start_ == finish_; }
};内存布局可视化：
start_ finish_ end_of_storage_
↓ ↓ ↓
[元素1][元素2][元素3][未使用][未使用][未使用]
|_____________|
已使用部分 剩余容量构造与初始化：多种创建方式
vector提供了丰富的构造函数，适应不同场景：
cpp
#include <vector>
#include <iostream>
void constructionDemo() {
// 1. 空vector
std::vector<int> vec1;
// 2. 指定大小和初始值
std::vector<int> vec2(5, 42); // [42, 42, 42, 42, 42]
// 3. 从原生数组初始化
int arr[] = {1, 3, 5, 7, 9};
std::vector<int> vec3(arr, arr + 5); // 使用迭代器范围
// 4. 初始化列表 (C++11)
std::vector<int> vec4 = {2, 4, 6, 8, 10};
// 5. 拷贝构造
std::vector<int> vec5(vec4);
// 6. 移动构造 (C++11) - 高效转移资源
std::vector<int> vec6(std::move(vec5));
std::cout << "vec5的大小: " << vec5.size() << std::endl; // 0 - 资源已被转移
}容量管理：size vs capacity的深刻理解
这是vector最容易被误解的概念，让我们彻底搞清楚：
cpp
void capacityDemo() {
std::vector<int> vec;
std::cout << "初始状态:" << std::endl;
std::cout << "size: " << vec.size()
<< ", capacity: " << vec.capacity() << std::endl;
// 添加元素，观察容量变化
for (int i = 0; i < 20; ++i) {
vec.push_back(i);
std::cout << "添加第" << (i+1) << "个元素: "
<< "size=" << vec.size()
<< ", capacity=" << vec.capacity() << std::endl;
}
}典型输出模式：
size=1, capacity=1
size=2, capacity=2
size=3, capacity=4
size=5, capacity=8
size=9, capacity=16
size=17, capacity=32看到规律了吗？vector采用几何增长策略，通常是2倍或1.5倍扩容，保证均摊时间复杂度为O(1)。
元素访问：安全与效率的平衡
vector提供了多种访问元素的方式，各有适用场景：
cpp
void accessDemo() {
std::vector<int> vec = {10, 20, 30, 40, 50};
// 1. 下标操作 - 最常用，但不检查边界
std::cout << "vec[2] = " << vec[2] << std::endl; // 30
// 2. at() - 边界检查，越界抛出异常
try {
std::cout << "vec.at(10) = " << vec.at(10) << std::endl;
} catch (const std::out_of_range& e) {
std::cout << "捕获异常: " << e.what() << std::endl;
}
// 3. 前端和后端访问
std::cout << "front: " << vec.front() << std::endl; // 10
std::cout << "back: " << vec.back() << std::endl; // 50
// 4. 数据指针 - 与C API交互时有用
int* data_ptr = vec.data();
std::cout << "通过指针访问: " << data_ptr[1] << std::endl; // 20
}修改操作：理解性能代价
不同的修改操作有着截然不同的性能特征：
尾部操作：O(1)时间复杂度
cpp
void tailOperations() {
std::vector<int> vec = {1, 2, 3};
// 尾部添加 - 高效
vec.push_back(4); // [1, 2, 3, 4]
vec.emplace_back(5); // [1, 2, 3, 4, 5] - 更高效，避免拷贝
// 尾部删除 - 高效
vec.pop_back(); // [1, 2, 3, 4]
std::cout << "最终内容: ";
for (int val : vec) {
std::cout << val << " ";
}
std::cout << std::endl;
}中间操作：昂贵的代价
cpp
void expensiveOperations() {
std::vector<int> vec = {1, 2, 3, 4, 5};
std::cout << "初始容量: " << vec.capacity() << std::endl;
// 在位置2插入元素 - O(n)操作
auto it = vec.begin() + 2;
vec.insert(it, 99); // [1, 2, 99, 3, 4, 5]
// 删除位置3的元素 - 同样O(n)
it = vec.begin() + 3;
vec.erase(it); // [1, 2, 99, 4, 5]
std::cout << "操作后内容: ";
for (int val : vec) {
std::cout << val << " ";
}
std::cout << std::endl;
}为什么中间操作这么慢？
插入前: [1][2][3][4][5][ ]
↑ 要在位置2插入99
插入时: [1][2][99][3][4][5] // 需要移动3,4,5三个元素内存管理：高级控制技巧
对于性能敏感的场景，我们需要精细控制vector的内存：
cpp
void memoryManagement() {
std::vector<int> vec;
// 预留容量 - 避免重复扩容
vec.reserve(1000); // 一次性分配足够内存
std::cout << "reserve后容量: " << vec.capacity() << std::endl;
for (int i = 0; i < 500; ++i) {
vec.push_back(i); // 不会触发扩容
}
// 收缩内存 - 释放多余容量
std::cout << "使用前容量: " << vec.capacity() << std::endl;
vec.shrink_to_fit(); // 请求释放未使用内存
std::cout << "收缩后容量: " << vec.capacity() << std::endl;
// 清空内容但不释放内存
vec.clear();
std::cout << "clear后大小: " << vec.size()
<< ", 容量: " << vec.capacity() << std::endl;
}迭代器：统一的访问接口
迭代器是STL的核心概念，提供容器无关的访问方式：
cpp
void iteratorDemo() {
std::vector<std::string> fruits = {"apple", "banana", "orange", "grape"};
// 1. 正向迭代器
std::cout << "正向遍历: ";
for (auto it = fruits.begin(); it != fruits.end(); ++it) {
std::cout << *it << " ";
}
std::cout << std::endl;
// 2. 反向迭代器
std::cout << "反向遍历: ";
for (auto rit = fruits.rbegin(); rit != fruits.rend(); ++rit) {
std::cout << *rit << " ";
}
std::cout << std::endl;
// 3. 常量迭代器 - 禁止修改
std::cout << "常量遍历: ";
for (auto cit = fruits.cbegin(); cit != fruits.cend(); ++cit) {
// *cit = "modified"; // 错误！不能修改
std::cout << *cit << " ";
}
std::cout << std::endl;
// 4. 基于范围的for循环 (C++11)
std::cout << "范围for循环: ";
for (const auto& fruit : fruits) {
std::cout << fruit << " ";
}
std::cout << std::endl;
}实战应用：性能敏感场景的优化
场景1：避免不必要的拷贝
cpp
// 低效写法
std::vector<std::string> getData() {
std::vector<std::string> data = {"large", "data", "set"};
return data; // 可能触发拷贝
}
// 高效写法
std::vector<std::string> getDataOptimized() {
std::vector<std::string> data = {"large", "data", "set"};
return data; // C++11起支持移动语义，无拷贝
}
void useData() {
// 直接构造，避免临时对象
auto data = getDataOptimized();
// 或者使用移动语义
std::vector<std::string> localData;
localData = std::move(data); // 资源转移，O(1)操作
}场景2：批量操作的优化
cpp
void batchOperations() {
// 情景：从文件读取大量数据
// 方法1：逐个push_back - 低效
std::vector<int> data1;
for (int i = 0; i < 1000000; ++i) {
data1.push_back(i); // 可能触发多次扩容
}
// 方法2：预留空间 + push_back
std::vector<int> data2;
data2.reserve(1000000); // 一次性分配
for (int i = 0; i < 1000000; ++i) {
data2.push_back(i); // 无扩容开销
}
// 方法3：直接赋值 - 最高效
std::vector<int> data3(1000000);
for (int i = 0; i < 1000000; ++i) {
data3[i] = i; // 直接访问，无函数调用开销
}
}高级特性：C++11/14/17的增强
移动语义与emplace操作
cpp
class Person {
public:
Person(const std::string& name, int age)
: name_(name), age_(age) {
std::cout << "构造函数: " << name_ << std::endl;
}
Person(const Person& other)
: name_(other.name_), age_(other.age_) {
std::cout << "拷贝构造: " << name_ << std::endl;
}
Person(Person&& other) noexcept
: name_(std::move(other.name_)), age_(other.age_) {
std::cout << "移动构造: " << name_ << std::endl;
}
private:
std::string name_;
int age_;
};
void modernVectorDemo() {
std::vector<Person> people;
// 传统方式 - 可能产生临时对象
people.push_back(Person("Alice", 25)); // 构造临时对象 + 移动
// 现代方式 - 原地构造
people.emplace_back("Bob", 30); // 直接在vector内存中构造
std::string name = "Charlie";
int age = 35;
people.emplace_back(name, age); // 传递参数，避免拷贝
}异常安全保证
vector提供强异常安全保证，确保操作失败时容器状态不变：
cpp
void exceptionSafety() {
std::vector<int> vec = {1, 2, 3, 4, 5};
try {
// 如果插入操作抛出异常，vector保持原有状态
vec.insert(vec.begin() + 2, 99);
} catch (const std::bad_alloc& e) {
// 内存分配失败，但vec仍然是{1,2,3,4,5}
std::cout << "内存分配失败，vector状态保持不变" << std::endl;
}
}性能测试：理论 vs 实践
让我们通过实际测试验证vector的性能特性：
cpp
#include <chrono>
void performanceTest() {
const int SIZE = 1000000;
// 测试1：预留容量 vs 不预留
auto start = std::chrono::high_resolution_clock::now();
std::vector<int> vec1;
for (int i = 0; i < SIZE; ++i) {
vec1.push_back(i);
}
auto end = std::chrono::high_resolution_clock::now();
auto time1 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
start = std::chrono::high_resolution_clock::now();
std::vector<int> vec2;
vec2.reserve(SIZE);
for (int i = 0; i < SIZE; ++i) {
vec2.push_back(i);
}
end = std::chrono::high_resolution_clock::now();
auto time2 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
std::cout << "无预留时间: " << time1.count() << "ms" << std::endl;
std::cout << "有预留时间: " << time2.count() << "ms" << std::endl;
std::cout << "性能提升: " << (time1.count() - time2.count()) << "ms" << std::endl;
}vector的局限性：何时不该使用vector
虽然vector很强大，但并非万能：
cpp
// 不适合使用vector的场景：
// 1. 频繁在头部插入删除
std::vector<int> vec;
vec.insert(vec.begin(), 1); // 需要移动所有元素！
// 2. 需要稳定的元素地址
std::vector<int> vec = {1, 2, 3};
int* ptr = &vec[1];
vec.push_back(4); // 可能触发扩容，ptr失效！
// 此时访问*ptr是未定义行为
// 3. 存储非常大的对象
struct VeryLargeObject {
char data[1000000]; // 1MB大小
};
std::vector<VeryLargeObject> largeVec; // 移动成本很高最佳实践总结
- 预分配原则 ：已知大小时使用
reserve()预留空间 - 尾部操作优先：尽量在尾部进行添加删除
- 避免中间修改：在中间插入删除前考虑其他数据结构
- 使用emplace：C++11以上使用emplace系列函数避免拷贝
- 注意迭代器失效：修改操作可能使迭代器、指针、引用失效
- 选择合适算法：结合STL算法获得最佳性能
cpp
// 良好实践示例
std::vector<int> createOptimizedVector() {
std::vector<int> result;
result.reserve(known_size); // 预分配
// 使用算法替代手动循环
std::generate_n(std::back_inserter(result), count, []() {
return generate_value();
});
return result; // 依赖移动语义或NRVO
}vector作为STL中最常用的容器，其设计体现了工程实践的智慧。理解其内部机制，我们就能在便利性与性能之间找到最佳平衡。
下一章预告：《数据结构手册003：链表list - 指针连接的灵活之美》
我们将探索非连续存储的魅力，理解何时应该放弃vector的连续优势，选择链表的灵活性。