揭开 C++ vector 底层面纱：从三指针模型到手写完整实现 - 指南
草莓熊Lotso：个人主页
❄️个人专栏：《C++知识分享》《Linux 入门到实践：零基础也能懂》
✨生活是默默的坚持，毅力是永久的享受
博主简介：
目录
3.2.2 resize 改变size：可能初始化或销毁元素
3.3.1 尾插(push_back)与尾删(pop_back)：
前言：
C++ 标准库中的 vector 堪称 “最常用容器”，它兼具数组的随机访问效率与动态扩容的灵活性，是开发和刷题的 “利器”。但很多开发者只停留在 “会用” 层面，对其底层实现原理一知半解。本文将从内存管理核心机制讲起，手把手带你实现一个功能完整的简化版 vector，涵盖构造 / 析构、扩容策略、迭代器设计等核心模块，让你彻底吃透这个 “动态数组” 的工作逻辑。
一. vector 底层核心：三指针控制内存
vector 的本质是动态管理连续内存的容器，其核心通过三个指针（迭代器）控制内存块：
- _start ：指向内存块的起始位置（第一个元素的地址）；
- _finish：指向有效元素的末尾（最后一个元素的下一位）；
- _end_of_storage：指向内存块的末尾（容量的边界）。
namespace Lotso
{
template
class vector
{
public：
//typedef T* iterator;
using iterator = T*;
using const_iterator = const T*;
private:
iterator _start;//数据起始位置
iterator _finish;//有效数据
iterator _end_of_storage;//空间
};
} 通过这三个指针，可直接计算：
- 有效元素个数（size）：_finish - _start
- 容量（capacity）：_end_of_storage - _start
public：
size_t capacity() const
{
return _end_of_storage - _start;
}
size_t size() const
{
return _finish - _start;
}二. 迭代器设计：连续内存的 “天然优势”
- vector的迭代器是对原生指针的封装，支持随机访问等操作，是很好用的
迭代器类型定义：
public:
//typedef T* iterator;
using iterator = T*;
using const_iterator = const T*;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}--我们这里迭代器的使用可以测试一下，实现的打印函数我就直接放上去了，之前讲过
- test.c：
namespace Lotso
{
void Print(const vector& v)
{
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
for (size_t i = 0; i < v.size(); i++)
{
//v[0]++;
cout << v[i] << " ";
}
cout << endl;
}
void test_vector1()
{
Lotso::vector v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
v.push_back(5);
v.push_back(5);
v.push_back(5);
v.push_back(5);
v.push_back(5);
v[0]++;
Print(v);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
}
int main()
{
Lotso::test_vector1();
return 0;
} 
三. 核心接口实现：从构造到析构的内存管理
3.1 构造与析构：vector的基础框架
--我们这里主要介绍一下无参构造，其它的就不多讲了
public:
vector()
:_start(nullptr)
,_finish(nullptr)
,_end_of_storage(nullptr)
{ }
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _end_of_storage = nullptr;
}
}3.2 容量管理：reserve 与 resize 的区别
3.2.1 reserve：仅扩容，不初始化元素
- reserve(n) 保证容量至少为 n，仅当 n>capacity 时才分配新内存，不改变 size。
public:
void reserve(size_t n)
{
if (n > capacity())
{
//先记录一下，不然后面start会变
size_t sz = size();
T* tmp = new T[n];
if (_start)
{
memcpy(tmp, _start, sizeof(T) * sz);
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_end_of_storage = _start + n;
}
}核心：reserve只管理内存，不创建或销毁元素，适合提前扩容以优化性能。
3.2.2 resize 改变size：可能初始化或销毁元素
- resize(n，val) 会将 size 调整为 n ，多余元素销毁，不足则用 val 填充。
void resize(size_t n, const T& val = T()) {
if (n > size()) {
// 1. 若容量不足，先扩容
if (n > capacity()) {
reserve(n);
}
// 2. 初始化新增元素
while (_finish < _start + n) {
new (_finish) T(val); // 定位 new 构造元素
++_finish;
}
} else {
// 3. 销毁多余元素
while (_finish > _start + n) {
--_finish;
_finish->~T();
}
}
}3.3 元素操作：增删查改的实现细节
3.3.1 尾插(push_back)与尾删(pop_back)：
尾插和尾删是 vector 最高效的操作（O (1)），只需检查容量并构造元素，销毁元素：
void push_back(const T& x)
{
if (_finish == _end_of_storage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*_finish = x;
++_finish;
}
void pop_back()
{
assert(!empty());
--_finish;
}3.3.2 插入（insert）：中间插入的性能代价
在指定位置插入元素需挪动后续元素，时间复杂度 O (n)：
public:
iterator insert(iterator pos, const T& x)
{
assert(pos >= _start);
assert(pos <= _finish);
// 扩容可能导致 pos 失效，需记录偏移量
if (_finish == _end_of_storage)
{
//提前记录一下
size_t len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + len;
}
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
return pos;
}
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}为什么从后往前挪？
- 若从前往后挪，会覆盖未移动的元素
3.3.3 访问元素：operator []
提供数组式访问，不做越界检查（高效）
T& operator[](size_t i)
{
assert(i < size());
return _start[i];
}
const T& operator[](size_t i) const
{
assert(i < size());
return _start[i];
}四. 避坑指南：vector 使用的 3 个核心陷阱
4.1 迭代器失效：扩容与删除的 “隐形炸弹”
扩容导致失效：reserve，push_back，insert 等可能触发扩容，旧内存被释放，迭代器变为野指针。解决：扩容后重新获取迭代器（如 insert 中通过偏移量修正 pos）。
- 删除导致失效：erase 或pop_back 后，指向被删元素的迭代器失效，后续元素迭代器可能偏移。解决：
erase返回下一个有效迭代器（见下方示例）：
// 正确删除偶数元素
auto it = v.begin();
while (it != v.end()) {
if (*it % 2 == 0) {
it = v.erase(it); // 用返回值更新迭代器
} else {
++it;
}
}--下面这些也可以参考一下
void test_vector2()
{
Lotso::vector v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
//v.push_back(5);
Print(v);
v.insert(v.begin(), 0);
Print(v);
auto it = v.begin() + 3;
// insert以后，it是否失效？
// it失效了，也就意味着，insert以后，it失效了，it就不能使用了
v.insert(it, 30);
Print(v);
}
void test_vector3()
{
Lotso::vector v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
Print(v);
v.erase(v.begin());
Print(v);
auto it = v.begin() + 2;
// it是否失效呢？失效，不能访问，访问结果未定义
v.erase(it);
Print(v);
}
void test_vector4()
{
Lotso::vector v;
v.push_back(1);
v.push_back(2);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
v.push_back(6);
// Print(v);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
// 删除所有的偶数
/*auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
v.erase(it);
}
++it;
}*/
auto it = v.begin();
while (it != v.end())
{
if (*it % 2 == 0)
{
it = v.erase(it);
}
else
{
++it;
}
}
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
} 4.2 浅拷贝风险：自定义类型必须深拷贝
若 vector 存储的是含指针的自定义类型（如 string），直接用 memcpy 拷贝会导致多个对象共享内存，析构时双重释放。本文实现的 reserve 和拷贝构造均用移动 / 拷贝构造函数迁移元素，避免了这一问题。
结尾：
往期回顾：
《吃透 C++ vector：从基础使用到核心接口实战指南》
结语：通过手写 vector，我们不仅理解了其底层的三指针模型、扩容策略和迭代器设计，更能在实际开发中规避迭代器失效、浅拷贝等陷阱。掌握这些原理，无论是使用标准库 vector 还是设计自定义容器，都会更加得心应手。
✨把这些内容吃透超牛的！放松下吧✨
ʕ˘ᴥ˘ʔ
づきらど
浙公网安备 33010602011771号