本文详细讲解了 C++ STL 中 vector 容器的底层模拟实现。内容涵盖 vector 的内存结构定义（_start/_finish/_endofstorage），默认成员函数（构造函数、拷贝构造、赋值重载、析构函数）的实现细节，以及迭代器的管理。重点阐述了容量相关接口（size/capacity/reserve/resize）的逻辑，并深入分析了增删查改操作（push_back/insert/erase/pop_back）中的内存管理与迭代器失效问题及其解决方案。通过手动实现，帮助读者理解动态数组的扩容机制、深拷贝原理及边界条件处理。
STL 容器是 C++ 开发中绕不开的'神兵利器'，而 vector 作为最常用的动态数组容器，更是新手入门 STL 的核心内容。但多数时候，我们只是'会用'vector，却对它的底层逻辑一知半解——比如它如何动态扩容？push_back 的内存管理是怎样的？构造函数的匹配规则为何如此复杂？
与其停留在'黑盒调用'的层面，不如亲手模拟实现一个 vector：从底层的指针管理（_start/_finish/_endofstorage），到核心接口（push_back/resize/operator[]），再到构造、拷贝等特殊函数的实现，一步步揭开 STL 容器的面纱。
本文不会纠结过于晦涩的标准细节，而是以'实用、易懂'为核心，带你用 C++ 手动实现一个具备基础功能的 vector——既能加深对容器原理的理解，也能锻炼 C++ 的底层编程能力。
简单说，vector 是 C++ 里可以动态变大小的数组——它既保留了普通数组'连续存储、下标访问高效'的优点，又解决了普通数组'大小固定、不能自动扩容'的痛点。
它的底层逻辑是动态分配的数组：
当你往 vector 里加新元素时，它会自动管理内存——如果当前数组存满了，就会重新分配一块更大的空间，把旧元素全搬过去，再继续存新元素（不过这个'搬家'操作开销不低，所以 vector 会提前多分配一些额外空间，避免频繁搬家）。
它的特点可以总结成'优劣势分明'：
**优势：**访问元素（用下标）、在末尾增删元素，效率都很高；
**劣势：**在中间 / 开头增删元素，效率很低（因为要挪动大量元素）；
对比其他容器（比如
list）：vector的访问更快，但灵活增删不如list。
namespace ayj // 避免与标准库 std::vector 命名冲突 {
// 模板类：实现动态数组 vector，T 为存储的元素类型（支持 int/string 等任意可拷贝类型）
template <class T>
class vector {
public:
// 迭代器类型定义：vector 的迭代器本质是原生指针（因底层连续内存）
typedef T* iterator; // 普通迭代器：支持读写元素
typedef const T* const_iterator; // 常量迭代器：仅支持读元素，不可修改
private:
// -------------------------- 核心指针（迭代器） --------------------------
// 1. 指向容器中第一个有效元素的起始位置
// 空容器时为 nullptr，有效元素范围：[_start, _finish)
iterator _start = nullptr;
// 2. 指向容器中最后一个有效元素的下一个位置（尾后迭代器）
// 空容器时为 nullptr，_finish - _start = 有效元素个数（size）
iterator _finish = nullptr;
// 3. 指向容器已分配内存空间的最后一个位置的下一个位置
// 空容器时为 nullptr，_endofstorage - _start = 总容量（capacity）
// 当_finish == _endofstorage 时，容器满，插入元素需扩容
iterator _endofstorage = nullptr;
};
}
这就是 vector 的核心底层结构——通过三个指针（_start/_finish/_endofstorage）管理连续内存，既实现了数组的高效访问，又能动态调整容量。
/* ===================== 构造函数 ===================== */
// 空构造：初始化空容器，无元素
vector() : _start(nullptr), _finish(nullptr), _endofstorage(nullptr) {}
// 填充构造：创建 n 个值为 val 的元素
vector(size_t n, const T& val = T()) { resize(n, val); }
// 范围构造：通过其他容器/序列的迭代器范围 [first,last) 初始化
template<class InputIterator>
vector(InputIterator first, InputIterator last) {
while (first != last) {
push_back(*first);
++first;
}
}
讲一个特殊的场景：
按道理来说我们是想用 10 个 1 构造一个 vector 这没啥问题吧，那为啥会编译不通过那，而且报的错误还是和迭代器范围构造相关的。
这是因为 vector<int> v(10, 1) 会误匹配此版本（10/1 被当作 InputIterator），此时 *first 会把 10 当作指针解引用，触发未定义行为（崩溃）。
这个时候有两种办法解决这个问题：
方法 1：
将 10 显式指定为 size_t 类型（写成 10u），这样编译器会优先匹配填充构造函数（而非范围构造函数），从而正常创建包含 10 个值为 1 的元素的 vector。
方法 2：
新增一个以 int 类型为参数的填充构造函数重载版本，让 vector<int> v(10, 1) 这类传入 int 型数值的场景，能直接匹配该重载函数，避免编译器误匹配范围构造函数。
// vector<int> v(10, 1)
vector(int n, const T& val = T()) { resize(n, val); }
C++ 函数匹配规则：
/*=====================拷贝构造传统写法========================*/
vector(const vector<T>& v) :
_start(nullptr), _finish(nullptr), _endofstorage(nullptr) {
_start = new T[v.capacity()]; //浅拷贝 - 容器存储的是有动态资源的自定义类型，使用 memcpy 就会造成浅拷贝
//memcpy(_start,v._start,sizeof(T)* v.size()); //深拷贝
for (size_t i = 0; i < v.size(); i++) {
_start[i] = v._start[i];
}
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
}
/*=====================拷贝构造现代写法========================*/
vector(const vector<T>& v) :
_start(nullptr), _finish(nullptr), _endofstorage(nullptr) {
reserve(v.capacity());
for (size_t i = 0; i < v.size(); i++) {
push_back(v[i]);
}
}
先来说传统写法：先给数组开辟对应空间，然后进行数据拷贝，最后更新 _finish 和 _endofstorage 指针。
这里需要注意：拷贝数据不能用 memcpy。因为如果数据类型是带有动态资源的自定义类型（比如 string），用 memcpy 拷贝会引发浅拷贝问题——它只会复制指针的值，不会复制指针指向的动态资源，最终导致多个对象共用同一块内存空间。
这个解决方案其实很简单：直接通过赋值操作完成拷贝即可。因为对于 string 这类自定义类型，赋值时会自动调用其赋值运算符重载函数，从而实现内部动态资源的深拷贝；而对于 int、double 等内置类型，赋值就是简单的数值拷贝，不会有任何额外影响。
/*=====================赋值重载现代写法========================*/
void swap(vector<T>& v) {
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
// v1 = v2
vector<T>& operator=(vector<T> v) {
swap(v);
return *this;
}
operator= 的参数是值传递（vector<T> v），会自动调用拷贝构造函数生成实参的临时副本；
借助 std::swap 交换当前对象和临时对象的内部指针，临时对象出作用域时会自动释放原当前对象的旧资源，避免内存泄漏；
返回 *this 以支持连续赋值（如 v1 = v2 = v3），符合赋值运算符重载的规范。
/*=====================赋值重载传统写法========================*/
vector<T>& operator=(vector<T>& v) {
T* tmp = new T[v.capacity()];
for (size_t i = 0; i < v.size(); i++) {
tmp[i] = v._start[i];
}
delete[] _start;
_start = tmp;
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
return *this;
}
这段赋值重载传统写法，先开辟临时空间深拷贝数据，再释放当前对象旧空间，最后更新指针并返回当前对象引用，实现安全且正确的深拷贝赋值。
~vector() {
if (_start) {
delete[] _start;
_start = _endofstorage = _finish = nullptr;
}
}
/*==========================迭代器=============================*/
iterator begin() {
return _start;
}
iterator end() {
return _finish;
}
const_iterator begin() const {
return _start;
}
const_iterator end() const {
return _finish;
}
迭代区间始终遵循 [begin, end) 的规则，以下是迭代器 begin() 与 end() 的边界定位示意图：
begin() 指向容器的第一个有效元素，end() 指向最后一个有效元素的下一个位置。
反向迭代器我们先暂时放一放，等后面学到 list 的反向迭代器时，vector 的反向迭代器写法也就自然掌握了。
size_t size() const {
return _finish - _start;
}
size_t capacity() const {
return _endofstorage - _start;
}
bool empty() const {
return size() == 0;
}
/*==========================扩容接口============================*/
void reserve(size_t n) {
if (n > capacity()) {
size_t sz = size();
T* tmp = new T[n];
if (_start) {
//浅拷贝 -- 如果存储的是带动态资源的自定义类型将就会有浅拷贝问题
//memcpy(tmp, _start, sizeof(T) * sz);
//每次调用赋值重载解决了浅拷贝问题
for (size_t i = 0; i < sz; i++) {
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
//_finish = _start + size() 错误代码;因为 size() 中的_start 和_finish 指的不是同一块空间
_finish = _start + sz;
_endofstorage = _start + n;
}
}
该接口用于为 vector 预留至少 n 个元素的存储空间，仅当 n 大于当前容器容量时才执行扩容操作；扩容时先记录当前有效元素个数，开辟 n 个大小的临时空间，通过循环调用元素赋值重载完成深拷贝（解决自定义类型动态资源的浅拷贝问题），随后释放原空间，更新容器的 _start、_finish、_endofstorage 指针，使容器容量更新为 n，且保留原有全部有效元素，有效避免频繁扩容带来的性能损耗。
扩容接口有两个特殊问题：
_start 指针会指向新空间，若此时再调用 size() 获取元素个数，会因 _start 和 _finish 不再指向原空间而计算错误，所以需要在扩容前先把当前元素个数存到 sz 变量中。/*=========================开空间 + 填值（resize 接口）===========================*/
void resize(size_t n, const T& val = T()) {
// 情况 1：n 小于当前有效元素个数，执行截断操作（保留前 n 个元素，后面的元素失效）
if (n < size()) {
// 直接调整_finish 指针，指向第 n 个元素的下一个位置，实现逻辑截断（物理空间仍保留原有容量）
_finish = _start + n;
}
// 情况 2：n 大于等于当前有效元素个数，执行扩容 + 填值操作
else {
// 调用 reserve 接口预留 n 个元素的空间，reserve 内部会判断 n 是否大于当前容量，仅需扩容时才会执行实际内存分配
reserve(n);
// 循环填充：从当前_finish 位置开始，到_start+n 位置结束，将新增空间填充为指定 val 值
while (_finish != _start + n) {
*_finish = val; // 给当前有效元素末尾的新位置赋值
_finish++; // 移动_finish 指针，扩大有效元素范围
}
}
}
这段 resize 接口用于调整 vector 的有效元素个数：
第二个参数的缺省值是调用默认构造，内置类型由于加入了模板，也有了自己的默认构造。
当 n 小于当前元素数时，直接截断（仅调整 _finish 指针，保留前 n 个元素）；
当 n 更大时，先调用 reserve 预留空间，再将新增位置填充为指定值，最终更新 _finish 指针，既支持缩小容器，也能安全扩容并填充元素。
void push_back(const T& x) {
// 判断是否需要扩容：当有效元素末尾指针等于容量末尾指针时，说明当前内存已满
if (_finish == _endofstorage) {
// 计算新容量：若当前容量为 0 则初始化为 4，否则扩容为原来的 2 倍（常用扩容策略）
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
// 调用 reserve 接口完成扩容，预留新容量空间
reserve(newcapacity);
}
// 给当前有效元素末尾赋值（尾插核心操作）
*_finish = x;
// 移动有效元素末尾指针，扩大有效元素范围
++_finish;
}
//指定位置插入
iterator insert(iterator pos, const T& x) {
assert(pos >= _start && pos <= _finish);
//扩容
if (_finish == _endofstorage) {
//记录 pos 相对位置
size_t len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
//解决内部迭代器失效问题
pos = _start + len;
}
iterator end = _finish - 1;
while (end >= pos) {
*(end + 1) = *end;
end--;
}
*pos = x;
++_finish;
//解决外部迭代器失效问题 - 指向新插入元素的位置
return pos;
}
insert 的参数 pos 在扩容时，原内存空间会被销毁回收，此时 pos 指向的旧地址会失效并变为野指针；而 (*pos)++ 对这个野指针进行了解引用操作，最终导致程序崩溃。
那我们该如何解决这个问题呢？
我标记的这两步是为了解决 pos 迭代器在函数内部失效的问题，通过记录扩容前 pos 和 _start 的相对位置以便于在扩容后更新 pos 的位置，让其指向新空间的当前位置。
返回更新后的 pos，解决外部迭代器失效问题。
第一个调用 v.insert(pos, 5)：传的是 pos 变量（左值迭代器），引用传参能直接修改外部 pos，所以没问题；
第二个调用 v.insert(v.begin(), 5)：传的是临时迭代器（右值），临时数据自带'常性'（不可修改），而引用传参要求修改它，这属于'权限放大'，因此会编译失败。
若未触发扩容：插入点之后的迭代器全部失效（元素后移导致指向错位，属于逻辑错位）；
// 指定位置删除元素
iterator erase(iterator pos) {
// 断言：确保 pos 迭代器合法（在有效元素区间内），且 vector 非空，防止非法访问
assert(pos >= _start && pos < _finish && size() > 0);
// 定义迭代器 it，从 pos 的下一个元素开始遍历
iterator it = pos + 1;
// 循环：将 pos 之后的所有元素依次向前移动一位，覆盖待删除元素（实现逻辑删除）
while (it != _finish) {
*(it - 1) = *it; // 后一个元素的值赋给前一个元素，完成前移覆盖
it++; // 迭代器后移，处理下一个元素
}
// 尾指针前移一位，缩小有效元素范围（底层内存未释放，仅标记该位置元素无效）
--_finish;
// 返回原 pos 迭代器（此时 pos 指向被删除元素的下一个有效元素，避免外部迭代器失效）
return pos;
}
情况 1：删除单个偶数（巧合没报错）
情况 2：删除连续偶数（迭代器失效导致跳过元素）
这个没删干净哦~，这是因为在删除第一个 2 后，这时候 it 指向第二个 2，但是 it++ 跳过了。
情况 3：删除末尾偶数（迭代器失效导致崩溃）
删除末尾偶数会触发死循环，当遍历到末尾偶数 6 并执行 erase(it) 后，it 迭代器失效且与更新后的 vector 尾指针重合，后续的 it++ 无法正常推进迭代器，导致循环条件 it != v.end() 永远成立，循环无法退出而陷入死循环，部分运行环境中也可能因失效迭代器操作触发内存越界崩溃。
综上所述，上述所有问题（巧合未报错、跳过元素、死循环 / 崩溃），本质都是错误的遍历删除逻辑导致的迭代器失效：代码直接在
erase后执行it++，没有利用erase返回的有效迭代器更新it，使得失效的迭代器参与后续操作，进而引发未定义行为（结果随机、逻辑错乱、程序异常）。正确的写法应是用
erase的返回值更新迭代器（删除元素时不执行it++，仅在未删除时推进），避免使用失效的旧迭代器，才能保证代码的正确性与稳定性。
核心结论：对 vector 执行 erase 或 insert 操作后，原迭代器必然失效（可能因内存销毁成野指针，或因元素移位逻辑错位），此时再访问该迭代器的结果是未定义的（可能巧合运行、跳过元素、死循环甚至崩溃）。
解决方案：若需继续操作容器，必须用 erase/insert 返回的新有效迭代器替代旧迭代器——这是 C++ 标准规定的唯一安全方式，确保每次操作都基于容器当前的有效状态。
简言之：旧迭代器作废，用返回的新迭代器续接操作。
不同编译器对失效迭代器的访问处理存在差异：比如在 VS 编译器中，一旦使用了失效的迭代器，程序会直接报错。
//尾删
void pop_back() {
erase(--end());
}
/*====================[]运算符重载=====================*/
// 可读可写版本：返回非 const 引用，支持修改元素值
T& operator[](size_t pos) {
assert(pos < size()); // 断言确保访问的下标合法，不越界
return _start[pos]; // 返回对应位置元素的引用，支持读和写
}
// 仅读版本：const 成员函数，返回 const 引用，禁止修改元素值
const T& operator[](size_t pos) const {
assert(pos < size()); // 断言确保访问的下标合法，不越界
return _start[pos]; // 返回对应位置元素的 const 引用，仅支持读操作
}
容器的 [] 访问多了逻辑 size 约束；
要求访问下标必须小于容器的 size（已初始化的有效元素数量），而普通数组仅受物理内存范围限制，无逻辑有效性检查。
vector<int> v;
v.reserve(10);
for (int i = 0; i < 10; i++) {
v[i] = i;
}
reserve(10) 仅预留内存，vector 的 size 仍为 0，直接用 v[i] = i（[] 下标访问运算符重载规定，i < size）属于越界访问未初始化内存，会导致未定义行为（如崩溃）。
正确做法：用 resize(10) 初始化 10 个元素（size=10），再下标赋值；或 reserve 后用 push_back 添加元素。
vector 自身并没有提供 find 接口，因此如果需要查找元素，要调用算法库中的 find 接口来实现。
template <class InputIterator, class T>
InputIterator find(InputIterator first, InputIterator last, const T& val) {
while (first != last) {
if (*first == val) {
return first;
}
first++;
}
return last;
}
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 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