C++ STL vector 动态数组是常用序列容器，基于动态数组实现，支持随机访问和自动扩容。详解初始化方式、核心成员函数（增删改查）、容量管理（size/capacity/reserve）及底层扩容机制。涵盖自定义类型存储、排序去重算法应用，并总结越界访问、迭代器失效等常见错误及优化方案，帮助开发者高效安全地使用 vector。
在 C++ STL 的序列式容器中，vector 无疑是最常用、最灵活、最贴合日常开发需求的容器之一。无论是笔试面试中的算法题，还是实际项目中的数据存储，vector 都能凭借其'动态扩容''随机访问'的核心优势，成为开发者的首选。
很多开发者对 vector 的认知停留在'可以自动变长的数组'，但其实它的底层实现、扩容机制、接口用法以及性能优化，都有很多值得深究的细节。本文将全面解析 vector——从基础用法到底层原理，从实操示例到避坑指南，助您深入掌握这个 STL'高频容器'，做到灵活运用、规避隐患。
vector 是 STL 标准模板库中的序列式容器，底层基于动态数组实现，本质是封装了动态分配内存的模板类。它可以存储任意数据类型（内置类型 int、float，自定义结构体、类等），支持动态扩容（无需手动管理内存大小），同时提供了便捷的接口，实现数据的增、删、改、查等操作。
[] 直接访问元素，时间复杂度为 O(1)，这是 vector 区别于 list（双向链表）的核心优势，适合频繁读取元素的场景。结合其优势，vector 适合以下场景，也是日常开发中最常遇到的场景：
在使用 vector 之前，需包含对应的头文件 #include <vector>，并建议使用 std 命名空间（或显式调用 std::vector）。下面从初始化开始，逐一讲解 vector 的核心基础操作，搭配示例代码，方便直接测试。
vector 的初始化方式灵活，可根据实际需求选择，不同方式的效率和适用场景略有差异，重点掌握前 3 种即可。
#include <iostream>
#include <vector>
using namespace std;
int main() {
// 方式 1：默认初始化，空 vector，容量为 0，后续添加元素时自动扩容
vector<int> v1;
// 方式 2：初始化 n 个元素，每个元素默认值为 0（内置类型），自定义类型需有默认构造
vector<int> v2(5); // v2: [0, 0, 0, 0, 0]
// 方式 3：初始化 n 个元素，每个元素赋值为指定值（推荐，高效）
vector<int> v3(5, 3); // v3: [3, 3, 3, 3, 3]
// 方式 4：通过已有数组/vector 初始化（拷贝构造）
int arr[] = {1, 2, 3, 4, 5};
vector<int> v4(arr, arr + 5); // v4: [1, 2, 3, 4, 5]（左闭右开区间）
vector<int> v5(v4); // 拷贝 v4，v5 与 v4 元素完全一致
// 方式 5：通过初始化列表初始化（C++11 及以上支持，最简洁）
vector<int> v6 = {1, 2, 3, 4, 5};
vector<int> v7{10, 20, 30}; // 省略等号，同样有效
// 打印测试
for (int i = 0; i < v7.size(); i++) {
cout << v7[i] << " ";
}
return 0;
}
vector 的成员函数众多，但常用的只有 10 个左右，我们按'访问、插入、删除、容量、其他'分类讲解，结合示例说明用法，避免记混。
operator[]：下标访问，与普通数组一致，无越界检查（高效，但不安全）；at()：下标访问，有越界检查，越界会抛出 out_of_range 异常（安全，效率略低）；front()/back()：访问第一个/最后一个元素，时间复杂度 O(1)（高频使用）。vector<int> v = {1, 2, 3, 4, 5};
cout << v[0] << endl; // 输出 1（无越界检查）
cout << v.at(2) << endl; // 输出 3（有越界检查）
cout << v.front() << endl; // 输出 1（第一个元素）
cout << v.back() << endl; // 输出 5（最后一个元素）
// 注意：v[10] 不会报错，但会访问非法内存（未定义行为）；v.at(10) 会直接抛出异常
push_back()：在 vector 尾部插入一个元素，时间复杂度 O(1)（无扩容时），最常用；insert()：在指定位置插入元素/元素组，时间复杂度 O(n)（需移动后续元素，效率较低）。vector<int> v = {1, 2, 3};
// 1. push_back：尾部插入
v.push_back(4); // v: [1, 2, 3, 4]
v.push_back(5); // v: [1, 2, 3, 4, 5]
// 2. insert：指定位置插入（需配合迭代器）
// 插入单个元素：在第 2 个位置（下标 1）插入 10
v.insert(v.begin() + 1, 10); // v: [1, 10, 2, 3, 4, 5]
// 插入多个相同元素：在第 3 个位置（下标 2）插入 2 个 20
v.insert(v.begin() + 2, 2, 20); // v: [1, 10, 20, 20, 2, 3, 4, 5]
// 插入另一个 vector 的元素：在末尾插入 v2 的所有元素
vector<int> v2 = {6, 7, 8};
v.insert(v.end(), v2.begin(), v2.end()); // v: [1,10,20,20,2,3,4,5,6,7,8]
pop_back()：删除尾部最后一个元素，时间复杂度 O(1)，最常用；erase()：删除指定位置/指定区间的元素，时间复杂度 O(n)（需移动后续元素）；clear()：清空 vector 中所有元素，但不释放内存（容量不变，size 变为 0）。vector<int> v = {1, 10, 20, 20, 2, 3, 4, 5};
// 1. pop_back：删除尾部元素
v.pop_back(); // v: [1, 10, 20, 20, 2, 3, 4]
// 2. erase：删除指定位置元素（下标 3 的元素 20）
v.erase(v.begin() + 3); // v: [1, 10, 20, 2, 3, 4]
// erase：删除指定区间元素（从下标 1 到下标 2，左闭右开）
v.erase(v.begin() + 1, v.begin() + 3); // v: [1, 2, 3, 4]
// 3. clear：清空所有元素
v.clear();
cout << v.size() << endl; // 输出 0（元素个数为 0）
cout << v.capacity() << endl; // 输出 4（容量不变，仍为之前的大小）
vector 的'容量（capacity）'和'大小（size）'是极易混淆的两个概念，必须重点区分：
vector<int> v;
cout << v.size() << " " << v.capacity() << endl; // 0 0（空 vector）
v.push_back(1);
cout << v.size() << " " << v.capacity() << endl; // 1 1（容量自动扩容到 1）
v.push_back(2);
cout << v.size() << " " << v.capacity() << endl; // 2 2（容量扩容到 2）
v.push_back(3);
cout << v.size() << " " << v.capacity() << endl; // 3 4（容量扩容到 4，通常是 2 倍扩容）
// resize：调整 size 为 5，新增元素默认值 0
v.resize(5);
cout << v.size() << " " << v.capacity() << endl; // 5 8（容量会自动扩容到不小于 size）
// resize：调整 size 为 3，删除末尾 2 个元素
v.resize(3);
cout << v.size() << " " << v.capacity() << endl; // 3 8（容量不变）
// reserve：提前分配容量为 10，不改变 size
v.reserve(10);
cout << v.size() << " " << v.capacity() << endl; // 3 10（容量变为 10，size 仍为 3）
swap()：交换两个 vector 的元素、size 和 capacity（高效，时间复杂度 O(1)）；data()：返回 vector 底层数组的首地址（可用于与 C 语言数组交互）。vector 支持多种遍历方式，可根据场景选择，其中'范围 for 循环'和'迭代器遍历'最常用，适配不同需求。
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> v = {1, 2, 3, 4, 5};
// 方式 1：普通 for 循环（下标访问，最直观，适合需要下标场景）
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;
// 方式 2：范围 for 循环（C++11 及以上，简洁，无需关心下标，仅遍历）
for (int val : v) {
cout << val << " "; // val 是 v 中元素的拷贝，修改 val 不影响原 vector
}
cout << endl;
// 范围 for 循环（修改原元素，需用引用）
for (int &val : v) {
val *= 2; // 修改原 vector 中的元素
}
// 方式 3：迭代器遍历（最通用，适配所有 STL 算法，推荐）
// 普通迭代器（可读可写）
vector<int>::iterator it;
for (it = v.begin(); it != v.end(); ++it) {
cout << *it << " "; // *it 访问迭代器指向的元素
}
cout << endl;
// 常量迭代器（只读，不允许修改元素）
vector<int>::const_iterator cit;
for (cit = v.cbegin(); cit != v.cend(); ++cit) {
cout << *cit << " ";
}
cout << endl;
// 方式 4：反向迭代器（从尾部到头部遍历）
vector<int>::reverse_iterator rit;
for (rit = v.rbegin(); rit != v.rend(); ++rit) {
cout << *rit << " "; // 输出：10 8 6 4 2
}
cout << endl;
return 0;
}
很多开发者使用 vector 时，只知道它能自动扩容，但不清楚扩容的底层逻辑，导致在频繁插入元素时，出现性能瓶颈或迭代器失效问题。这一部分，我们就来拆解 vector 的扩容机制，搞懂'为什么扩容''怎么扩容''扩容有什么隐患'。
vector 底层是连续的动态数组，一旦数组被分配，内存地址就固定了。当我们通过 push_back() 插入元素，且当前 size == capacity 时，vector 就会触发'扩容'，扩容的核心步骤是：
从扩容的步骤可以看出，扩容是一个'耗时操作'——涉及内存分配、元素拷贝、原内存释放，这些操作的时间复杂度是 O(n)（n 为当前元素个数）。如果频繁插入元素，会触发多次扩容，导致性能下降。
举个例子：如果我们要插入 1000 个元素，vector 初始容量为 0，每次扩容 2 倍，那么会触发的扩容次数为：0→1→2→4→8→16→32→64→128→256→512→1024，共 11 次扩容，每次扩容都要拷贝当前所有元素，累计拷贝次数较多。
针对扩容的性能损耗，STL 提供了 reserve() 函数，允许我们提前分配足够的容量，避免频繁扩容。比如上面的例子，我们提前 reserve(1000)，就可以只分配一次内存，插入 1000 个元素时无需触发任何扩容，大幅提升性能。
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> v1;
vector<int> v2;
// v2 提前分配容量 1000，避免扩容
v2.reserve(1000);
// 插入 1000 个元素，对比两者性能（肉眼可见 v2 更快）
for (int i = 0; i < 1000; i++) {
v1.push_back(i);
v2.push_back(i);
}
cout << v1.capacity() << endl; // 1024（多次扩容后的容量）
cout << v2.capacity() << endl; // 1000（提前分配的容量）
return 0;
}
注意：reserve() 只能增大容量，不能减小容量；如果传入的参数小于当前容量，reserve() 不会做任何操作。
这是 vector 使用中最常见的'坑'——当 vector 触发扩容后，原内存被释放，指向原内存的迭代器、指针、引用都会变成'野指针'，继续使用会导致程序崩溃或未定义行为。
vector<int> v = {1, 2, 3};
vector<int>::iterator it = v.begin(); // it 指向原内存的第一个元素（地址假设为 0x123）
// 插入元素，触发扩容（原容量 3，插入第 4 个元素，扩容到 6）
v.push_back(4);
v.push_back(5);
v.push_back(6);
v.push_back(7); // 触发扩容，原内存释放，it 变成野指针
// 继续使用 it，未定义行为（可能崩溃、输出乱码）
// cout << *it << endl;
// 解决方法：扩容后，重新获取迭代器
it = v.begin();
cout << *it << endl; // 正常输出 1
vector 不仅支持内置类型，还支持自定义结构体、类，同时可以与 STL 算法协同使用，实现排序、去重等高级操作，这也是 vector 高频使用的场景之一。
存储自定义结构体时，需确保结构体有默认构造函数（如果手动定义了带参构造，需显式定义默认构造），否则初始化时会报错。
#include <iostream>
#include <vector>
#include <string>
using namespace std;
// 自定义结构体：学生信息
struct Student {
string name;
int age;
int score;
// 默认构造函数（必须有，否则 vector<Student> v(5) 会报错）
Student() : name(""), age(0), score(0) {}
// 带参构造函数（方便初始化）
Student(string n, int a, int s) : name(n), age(a), score(s) {}
};
int main() {
// 初始化自定义结构体 vector
vector<Student> students;
students.push_back(Student("张三", 18, 90));
students.push_back(Student("李四", 19, 85));
students.push_back(Student("王五", 18, 95));
// 遍历输出
for (const auto& stu : students) {
// 用 const 引用，避免拷贝，提高效率
cout << "姓名：" << stu.name << "，年龄：" << stu.age << "，成绩：" << stu.score << endl;
}
return 0;
}
sort 是 STL 最常用的排序算法，vector 支持随机访问迭代器，因此可以直接使用 sort 对 vector 进行排序。默认是升序排序，也可以自定义排序规则（降序、按结构体字段排序等）。
#include <iostream>
#include <vector>
#include <algorithm> // sort 算法头文件
using namespace std;
// 自定义排序规则：降序排序（函数形式）
bool cmpDesc(int a, int b) {
return a > b; // a > b 时，a 排在 b 前面，即降序
}
// 自定义结构体
struct Student {
string name;
int score;
// 按成绩降序排序（成员函数形式，可选）
bool operator<(const Student& other) const {
return score > other.score;
}
};
int main() {
// 1. 内置类型排序
vector<int> v1 = {3, 1, 4, 1, 5, 9};
sort(v1.begin(), v1.end()); // 默认升序：1 1 3 4 5 9
sort(v1.begin(), v1.end(), cmpDesc); // 自定义降序：9 5 4 3 1 1
// 2. 自定义结构体排序（两种方式）
vector<Student> v2;
v2.push_back({"张三", 90});
v2.push_back({"李四", 85});
v2.push_back({"王五", 95});
// 方式 1：使用成员函数 operator<（已定义按成绩降序）
sort(v2.begin(), v2.end());
// 方式 2：使用 lambda 表达式（更灵活，无需定义额外函数）
sort(v2.begin(), v2.end(), [](const Student& a, const Student& b) {
return a.score > b.score; // 按成绩降序
});
// 遍历输出
for (const auto& stu : v2) {
cout << stu.name << "：" << stu.score << endl;
}
return 0;
}
vector 本身没有去重接口，但可以通过 STL 的 unique 算法（去重）+ erase 函数（删除重复元素）实现去重。注意：unique 算法只能去除'相邻的重复元素'，因此去重前必须先排序。
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
vector<int> v = {3, 1, 4, 1, 5, 9, 5, 3};
// 步骤 1：先排序，让重复元素相邻
sort(v.begin(), v.end()); // 排序后：1 1 3 3 4 5 5 9
// 步骤 2：unique 去重，返回指向第一个重复元素的迭代器
auto it = unique(v.begin(), v.end()); // 去重后：1 3 4 5 9 ? ? ?（后面的元素未删除）
// 步骤 3：erase 删除重复元素（从 it 到末尾）
v.erase(it, v.end());
// 输出去重后的结果：1 3 4 5 9
for (int val : v) {
cout << val << " ";
}
return 0;
}
结合前面的讲解，总结 vector 使用中最容易出现的 5 个错误，以及对应的解决方案，帮你规避隐患，写出更安全、高效的代码。
错误：使用 v[i] 访问下标超出 size()-1 的元素（如 v.size() 为 5，访问 v[5]），无越界检查，导致程序崩溃或未定义行为。
解决方案：
错误：扩容后继续使用原迭代器、指针、引用；或在 erase() 后继续使用被删除位置的迭代器。
解决方案：
错误：认为 v.capacity() == v.size()，或用 capacity() 判断元素个数（如 for (int i = 0; i < v.capacity(); i++)）。
解决方案：
错误：在 vector 中间频繁插入/删除元素（如 v.insert(v.begin() + 1, val)），导致大量元素移动，性能低下。
解决方案：
错误：vector 存储指针类型（如 vector<int*>）时，只 clear() 清空元素，未释放指针指向的内存，导致内存泄漏。
解决方案：
// 错误示例：内存泄漏
vector<int*> v;
v.push_back(new int(1));
v.push_back(new int(2));
v.clear(); // 仅清空元素，未释放 new 分配的内存，导致内存泄漏
// 正确示例：手动释放内存
vector<int*> v;
v.push_back(new int(1));
v.push_back(new int(2));
// 遍历释放内存
for (int* p : v) {
delete p; // 释放指针指向的内存
p = nullptr; // 避免野指针
}
v.clear(); // 再清空元素
vector 作为 STL 中最常用的容器，其核心价值在于'平衡了效率与便捷性'——既有普通数组的随机访问高效性，又有动态数组的灵活性，同时封装了内存管理，让开发者无需关注底层细节。
最后，给大家几点使用建议，帮助你更好地运用 vector：
[]（高效），调试时可用 at()（安全）；vector 的用法看似简单，但想要真正用好、用活，需要深入理解其底层扩容机制和注意事项。希望本文解析助您深入掌握 vector，在笔试面试和实际开发中，都能灵活运用这个 STL'利器'。
最后，附上核心示例代码汇总，便于参考验证：
// 本文核心示例代码汇总
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;
// 1. 初始化与基础操作
void testInitAndBase() {
vector<int> v1;
vector<int> v2(5, 3);
vector<int> v3 = {1, 2, 3, 4, 5};
v3.push_back(6);
v3.insert(v3.begin() + 2, 10);
v3.pop_back();
v3.erase(v3.begin() + 1);
for (int val : v3) {
cout << val << " ";
}
cout << endl;
}
// 2. 容量操作与扩容优化
void testCapacity() {
vector<int> v;
v.reserve(10);
for (int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << "size: " << v.size() << ", capacity: " << v.capacity() << endl;
}
// 3. 自定义结构体与排序
struct Student {
string name;
int score;
Student(string n, int s) : name(n), score(s) {}
};
void testSort() {
vector<Student> v = {{"张三", 90}, {"李四", 85}, {"王五", 95}};
sort(v.begin(), v.end(), [](const Student& a, const Student& b) {
return a.score > b.score;
});
for (const auto& stu : v) {
cout << stu.name << "：" << stu.score << endl;
}
}
// 4. 去重操作
void testUnique() {
vector<int> v = {3, 1, 4, 1, 5, 9, 5, 3};
sort(v.begin(), v.end());
auto it = unique(v.begin(), v.end());
v.erase(it, v.end());
for (int val : v) {
cout << val << " ";
}
cout << endl;
}
// 5. 指针类型 vector，避免内存泄漏
void testPointer() {
vector<int*> v;
v.push_back(new int(1));
v.push_back(new int(2));
for (int* p : v) {
delete p;
p = nullptr;
}
v.clear();
cout << "内存释放完成" << endl;
}
int main() {
testInitAndBase();
testCapacity();
testSort();
testUnique();
testPointer();
return 0;
}
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online