目录
-
- [一、 结构与底层骨架设计](#一、 结构与底层骨架设计)
-
- [1.1 文件划分与命名空间隔离](#1.1 文件划分与命名空间隔离)
- [1.2 为什么 采用"三指针"作为底层成员?](#1.2 为什么 采用“三指针”作为底层成员?)
- [二、 四大核心功能逐层构建](#二、 四大核心功能逐层构建)
-
- [2.1 容量控制模块:`reserve`](#2.1 容量控制模块:
reserve) -
- [2.1.1 封装通用打印接口 `print_vector`](#2.1.1 封装通用打印接口
print_vector)
- [2.1.1 封装通用打印接口 `print_vector`](#2.1.1 封装通用打印接口
- [2.2 尾插尾删与随机访问:`push_back`、`pop_back`、`operator\[\]`](#2.2 尾插尾删与随机访问:
push_back、pop_back、operator[]) - [2.3 任意位置增删:`insert` 与 `erase`](#2.3 任意位置增删:
insert与erase) - [2.4 构造、拷贝与赋值的"现代写法"](#2.4 构造、拷贝与赋值的“现代写法”)
-
- [2.4.1 构造函数](#2.4.1 构造函数)
- [2.4.2 拷贝构造函数](#2.4.2 拷贝构造函数)
- [2.4.3 赋值重载函数](#2.4.3 赋值重载函数)
- [2.1 容量控制模块:`reserve`](#2.1 容量控制模块:
- [三、 实战踩坑实录:从编译报错到内存崩溃](#三、 实战踩坑实录:从编译报错到内存崩溃)
-
- [坑位 1:拷贝构造采用`memcpy` 引发的"双重析构"惨案](#坑位 1:拷贝构造采用
memcpy引发的“双重析构”惨案) - [坑位 2:匿名对象与常引用权限(`const T& val = T()`)](#坑位 2:匿名对象与常引用权限(
const T& val = T())) - [坑位 3:`const` 对象的权限传递与 E0349 报错](#坑位 3:
const对象的权限传递与 E0349 报错)
- [坑位 1:拷贝构造采用`memcpy` 引发的"双重析构"惨案](#坑位 1:拷贝构造采用
- [四、 进阶思考:还能怎么打磨?](#四、 进阶思考:还能怎么打磨?)
📌 相关专栏与源码导航:
- 💻 配套源码: 🚀 本专栏所有配套代码已同步至 GitHub,点击直达
- 📚 系统专栏:
前言 :在上一篇《手撕 string》中,我们通过字符数组完成了动态内存管理与深浅拷贝的首次实战。今天,我们正式进军 STL 最核心的序列式容器------std::vector,在自己的命名空间下从零手搓一个属于自己的 vector。
写容器模拟实现最核心的思路是"先搭骨架、再填血肉、最后排雷"。本文将带你从最基础的工程结构与三指针底层设计起步,一步步搭建出
vector的完整模块,并复盘我在联调过程中踩进的几个内存与权限深坑。
一、 结构与底层骨架设计
在动手写第一行核心逻辑之前,先把结构和底层内存模型定下来,避免和标准库 std::vector 发生命名冲突。
1.1 文件划分与命名空间隔离
模拟实现采用声明与测试分离的结构:
-
vector.h:存放类模板vector的全部实现(因为模板不支持声明和定义分离编译,所有成员函数直接写在头文件中),并用自定义命名空间namespace hhy包裹,确保测试时与std::vector彻底隔离。 -
test.cpp:引入vector.h,按功能模块拆分,写一块、测一块。
1.2 为什么 采用"三指针"作为底层成员?
回顾我们上一篇实现 string 时,底层用的是 _str(指针)+ _size + _capacity(两个整型)。但在参考 STL 源码设计 vector 时,成员变量直接换成了三个同类型的原生指针:
cpp
namespace hhy
{
template <class T>
class vector
{
public:
//迭代器的创建
typedef T* iterator;
typedef const T* const_iterator;
// 基础容量与迭代器接口
size_t size() const { return _finish - _start; }
size_t capacity() const { return _end_of_storage - _start; }
bool empty() const { return _start == _finish; }
iterator begin() { return _start; }
iterator end() { return _finish; }
const_iterator begin() const { return _start; }
const_iterator end() const { return _finish; }
// ... 核心接口区 ...
private:
// 三指针底层骨架
iterator _start = nullptr; // 指向数据块的起始位置
iterator _finish = nullptr; // 指向有效数据的尾(最后一个元素的下一个位置)
iterator _end_of_storage = nullptr; // 指向整块已开辟存储空间的尾
};
}
这套三指针架构完美契合 STL 左闭右开 [_start, _finish) 的设计,使得容量计算和遍历变得极其简洁:
-
有效元素个数
size():直接指针相减_finish - _start。 -
当前总容量
capacity():同样指针相减_end_of_storage - _start。 -
迭代器接口
begin()/end():直接返回_start和_finish(需同时重载普通版和 const 版,以支持普通遍历和只读对象的范围for循环)。

vector的底层是一块连续的内存,所以我们可以通过原生指针进行对内容的访问,所以我们能够对参数进一步封装为迭代器。

注意: \colorbox{#E53935}{\color{#FFFFFF}\text{ 注意: }} 注意:
后续的使用中我们会传入const对象,那么在使用迭代器时需要权限平衡,所以我们还需要重载const版本的迭代器
二、 四大核心功能逐层构建
骨架搭好之后,我们按照从基础到进阶的顺序,把 vector 的功能拆分成四个模块逐步实现:
2.1 容量控制模块:reserve
vector 动态扩容的核心全都在 reserve :
reserve(size_t n):只负责开空间,不改变有效元素个数。当n > capacity()时,异地开辟大小为n的新空间tmp,将旧数据迁移过去后释放旧空间,最后统一更新三指针的位置。
cpp
void reserve(size_t n)
{
if (n > capacity())
{
size_t old_size = size();//❗❗❗❗❗❗❗
T* tmp = new T[n];
for (size_t i = 0; i < old_size; i++)
{
tmp[i] = _start[i];
}
delete[] _start;
_start = tmp;
_finish = _start + old_size;
_end_of_storage = _start + n;
}
}
核心避坑 : ⚠️ ⚠️ ⚠️ \colorbox{#E53935}{\color{#FFFFFF}\text{ 核心避坑 : ⚠️ ⚠️ ⚠️ }} 核心避坑 : ⚠️ ⚠️ ⚠️
在更新指针位置的时候,一定要提前记录原来_finish 与 _start的相对距离。
- 翻车现场 :一旦先执行了
delete[] _start;,原本的_start就失效了!此时再调size()(即_finish - _start),算出来的偏移量完全是错的,导致_finish依然指向已经释放掉的旧空间位置,后续尾插直接越界崩溃。
⚠️ 注意:若不记录,在更新_finish时直接调用size(),此时_start地址已经被改变为tmp的地址但是_finish还是原来的旧地址,两地址相减无法得出相对距离。
2.1.1 封装通用打印接口 print_vector
为了方便后续测试,我们在这里写一个函数模板(参数类型T可能为任何类型,所以需要函数模板而非普通函数),而且注意这个模板的位置,它不最为类成员,所以需要写到类模板外
cpp
template<class T>
void print_vector(const vector<T>& v)
{
typename vector<T>::const_iterator it = v.begin();
//while (it != v.end())
//{
// cout << *it << " ";
// it++;
//}
//cout << endl;
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
核心避坑 :为什么需要typename \colorbox{#E53935}{\color{#FFFFFF}\text{ 核心避坑 :为什么需要typename}} 核心避坑 :为什么需要typename
在模板中,通过 :: 从类中取东西时,编译器会进行检查,如果类是一个未实例化的模板,那么编译器默认会当成变量,因此必须加 typename 声明它是类型;如果类已经实例化,那么取出来既可以是类型也可以是变量。
解释:
你或许会疑惑,我们不是已经传入参数了吗?编译器为什么不知道啊?
这是因为当我们Ctrl + F5运行程序时,先预处理展开头文件(一股脑将.h文件内容放到.cpp中),然后编译器会先对代码进行初步的语法检查 (模板定义期检查)。当扫描到
print_vector时,虽然看到我们通过 vector::const_iterator从类模板里取一个东西,但此时模板还没有被具体类型实例化,编译器不敢进到类模板内部去翻找定义,也就无法确定const_iterator究竟是一个嵌套类型 ,还是一个静态成员变量 。为了避免歧义,编译器默认把它当成静态变量 来处理------这样一来,原本的"类型 + 变量名"定义语句,在编译器眼里就变成了
变量 it = v.begin();(两个变量名直接连写),语法瞬间非法,编译自然就报错了!只有加上typename关键字,才相当于明确告诉编译器:"别猜了,这是个类型!"
2.2 尾插尾删与随机访问:push_back、pop_back、operator[]
- 尾插与尾删 :
push_back先判断_finish == _end_of_storage(满了就按 2 倍扩容,初始容量为 0 时默认给 4),再在*_finish处赋值并让_finish++;pop_back在非空前提下直接_finish--。
*注意:插入前判满,删除前判空
cpp
void push_back(const T& val)
{
if (_finish == _end_of_storage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
(*_finish) = val;
_finish++;
}
void pop_back()
{
if (!empty())
{
_finish--;
}
}
与string类似,我们的尾删并非真正物理意义上的内存删除,而是限制访问范围即可,等后续如果插入直接覆盖写入。
我们来测试一下看看功能是否正确

写完一个功能测试一个功能更不容易出错
- 随机访问
cpp
T& operator[](size_t n)
{
assert(n < size());
return _start[n];
}
const T& operator[](size_t n) const
{
assert(n < size());
return _start[n];
}
2.3 任意位置增删:insert 与 erase
insert(iterator pos, const T& val):断言检查pos合法性后,先判断是否触发扩容(扩容前必须先算好相对偏移量len,扩容后重新定位pos);随后从_finish往后倒着挪动元素,腾出pos位置填入val,最后_finish++并返回更新后的pos。
cpp
iterator insert(iterator pos, const T& val)
{
assert(pos >= _start);
assert(pos <= _finish);
if (_finish == _end_of_storage)
{
size_t len = pos - _start;
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + len;
}
iterator end = _finish;
while (pos < end)
{
*(end) = *(end - 1);
end--;
}
*(pos) = val;
_finish++;
return pos;
}
动画演示:

核心避坑 : \colorbox{#E53935}{\color{#FFFFFF}\text{ 核心避坑 :}} 核心避坑 :
这里存在迭代器失效问题,当空间不足时发生扩容,异地开辟新的空间,但是pos仍然指向原来的旧空间。
例如图示 :
所以我们需要在扩容部分,对pos进行单独处理,记录与_start的相对距离,扩容完成后更新pos的指向。
erase(iterator pos):从pos开始,用后面的元素依次向前覆盖(注意循环边界停在_finish - 1,防止越界读取),最后_finish--并返回删除位置的下一个有效迭代器。
cpp
iterator erase(iterator pos)
{
assert(pos >= _start);
assert(pos < _finish);
iterator it = pos;
iterator end = _finish - 1; // 向前挪一位,防止越界访问
while (it < end)
{
*it = *(it + 1);
it++;
}
_finish--;
return pos;
}
动画演示:

优点显现:
此时使用原生指针的优点也体现出来了,上次模拟string是利用 和下标对内容进行修改,很容易因为有无符号问题造成错误,但是原生指针不会在存在这种问题,只需要控制好越界问题即可。
测试观察一下

可以明显地观察到,所有功能都可以正常运行,我们继续学习下一个操作。
2.4 构造、拷贝与赋值的"现代写法"
疑惑解答: \colorbox{#FFEAEA}{\color{#C22828}\text{疑惑解答:}} 疑惑解答:
在以往模拟实现 string 时,我们一上来就会先把构造函数写好,为什么这次 vector 却把构造、拷贝等默认成员函数放到了最后呢?
核心原因在于空对象是否涉及底层的动态空间申请:
string必须开空间,而vector不需要 :在模拟实现string时,为了兼容 C 语言的
c_str(),哪怕是空字符串,底层也必须存放一个结束标志'\0',因此无参构造时就必须在堆上new申请出一块保底空间;但vector存放的是通用数据,没有'\0'的概念 ,空vector不需要申请任何堆空间,只需利用成员变量的缺省值将成员变量全部置为nullptr即可,真正需要空间时再由reserve按需开辟。
所以无资源分配问题,默认构造函数会利用缺省值自动初始化。
在构建默认成员函数和区间构造时,充分复用已经写好的 reserve 和 push_back 接口:
2.4.1 构造函数
- 全缺省构造与迭代器区间构造 :前者兼顾无参构造与
n个val初始化;后者使用成员函数模板InputIterator,支持用任意容器(如string)的迭代器区间构造vector。
全缺省构造: \colorbox{#FFEAEA}{\color{#C22828}\text{全缺省构造:}} 全缺省构造:
cpp
// 全缺省构造函数
vector(size_t n = 0, const T& val = T())
{
reserve(n);
for (size_t i = 0; i < n; i++)
{
push_back(val);
}
} delete[] _start;
_start = tmp;
_finish = _start + old_size;
_end_of_storage = _start + n;
}
}
问题解答:const T val = T() 是什么? \colorbox{#E53935}{\color{#FFFFFF}\text{ 问题解答:const T val = T() 是什么?}} 问题解答:const T val = T() 是什么?
T()匿名对象与内置类型的"伪构造" :vector存储的元素类型T是不确定的。如果是自定义类型(如vector<string>),T()会调用string的无参构造生成一个空字符串作为默认值;而为了兼容泛型,C++规定内置类型(如int、double、指针等)同样支持T()语法 ------例如int()会初始化为0,double()为0.0,指针为nullptr。
💡 认知升级: 我们以前认为"编译器默认生成的构造函数对内置类型成员不做处理"(值为随机值),但在引入模板后,为了兼容泛型编程,C++ 在语法层面上让内置类型也拥有了自己的"构造函数"(即值初始化)------例如 int() 会默认初始化为 0,double() 为 0.0,指针为 nullptr。
迭代器区间构造: \colorbox{#FFEAEA}{\color{#C22828}\text{迭代器区间构造:}} 迭代器区间构造:
cpp
// 迭代器区间构造
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
first++;
}
}
为什么要单独写成模板函数呢?
因为我们不确定传入迭代器是什么类型数据,可能是vector< string> 也可能是vector< vector>
2.4.2 拷贝构造函数
充分复用已经写好的 reserve 和 push_back接口:
cpp
// 拷贝构造函数(利用现成接口)
vector(const vector<T>& v)
{
reserve(v.capacity());
for (auto& e : v)
{
push_back(e);
}
}
2.4.3 赋值重载函数
赋值重载直接通过传值形参 vector<T> v 自动触发拷贝构造生成副本,再 swap(v) 交换三指针,出作用域时临时对象自动析构顺带释放旧空间。
cpp
// 赋值重载(现代写法:传值触发拷贝构造 + swap)
void swap(vector<T>& it)
{
std::swap(_start, it._start);
std::swap(_finish, it._finish);
std::swap(_end_of_storage, it._end_of_storage);
}
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
三、 实战踩坑实录:从编译报错到内存崩溃
模块搭好后,我在 test.cpp 中逐一放开测试用例进行联调,结果遇到了几个极具代表性的底层问题,每一个背后都藏着 C++ 核心语法与内存模型的逻辑:
坑位 1:拷贝构造采用memcpy 引发的"双重析构"惨案
在 测试 中,我用 vector<int> 测试尾插、尾删、中间插入全都能正常跑通;可一到 vector_test04 换成 vector<string> 并触发扩容,程序直接崩溃!
我们先来看错误版本的reserve函数:

在这里memcpy进行每字节的拷贝操作,将_start指向的内容拷贝给tmp发生浅拷贝,两个指针指向同一块地址。

- 翻车原因 :最初在
reserve里我直接用了memcpy(tmp, _start, old_size * sizeof(T))搬运数据。 * 对于int这种内置类型,按字节拷贝毫无问题。 * 但对于std::string这种内部管理着堆内存指针 的自定义类型,memcpy只是把string对象里的指针地址原封不动地按字节抄到了tmp里(浅拷贝 )。紧接着执行delete[] _start;时,旧空间里的string调用析构函数把堆上的字符串释放了,tmp里存的瞬间全成了悬空野指针!- 破局解法 :老老实实用
for循环配合赋值重载逐元素拷贝(tmp[i] = _start[i];),调用T自身的深拷贝赋值运算符:
坑位 2:匿名对象与常引用权限(const T& val = T())
在实现全缺省构造函数 vector(size_t n = 0, const T& val = T()) 时,我产生过一个疑问:这里为什么必须在 T& 前面加上 const?
-
底层剖析 :当调用者只传
n(甚至无参构造vector<int> v;)时,第二个参数会使用缺省值T()------这是一个匿名临时对象 。在 C++ 中,临时对象具有常性(右值属性),如果形参写成非const的普通引用T& val,就会触发"权限放大"导致编译报错。加上const既延长了匿名对象的生命周期,又避免了传值带来的额外拷贝开销。 -
延伸思考(二级指针权限) :写测试时我还顺手验证了一组经典对比(见
test.cpp末尾注释):cppint i = 10; const int& j = i; // 合法:权限缩小 int* k = &i; const int*& l = k; // 报错!这是经典的二级指针权限放大陷阱,必须写成 const int* const& l = k;
坑位 3:const 对象的权限传递与 E0349 报错
在写拷贝构造函数 vector(const vector<T>& v) 时:
- 内部调用
v.capacity()提前开空间,如果capacity()成员函数后面漏写了const修饰(size_t capacity() const),const对象v就无法调用它,直接报错。 - 同理,如果后续在拷贝构造或只读场景下使用
v[i]访问元素,必须同时提供const T& operator[](size_t n) const重载,否则只有普通版T& operator[](size_t n)时,编译器会直接抛出E0349: 没有与这些操作数匹配的 "[]" 运算符。
四、 进阶思考:还能怎么打磨?
这版代码已经能顺利通过所有基础与深拷贝测试,还有两个非常有意思的进阶细节值得继续深挖:
- 构造函数重载冲突 :当同时存在
vector(size_t n, const T& val)和模板构造template <class InputIterator> vector(InputIterator first, InputIterator last)时,如果调用vector<int> v(10, 7);,编译器会认为两个int匹配模板版本更精准(不需要从int隐式转size_t),从而在函数体内对int解引用*first报错------标准库通过额外重载vector(int n, const T& val)巧妙化解了这个问题。 - 外部迭代器失效规范 :目前
insert和erase在修正后返回了更新后的迭代器iterator,调用方在执行删除或插入后,必须用返回值重新接收(it = v.erase(it);),绝不能直接继续使用旧的迭代器。
"不必急于证明自己,沉下心走好脚下的每一步,时间自会给出答案。"
Crafted with passion by Hhy
当前更新时间:{{ 2026 / 11 / 16 }} | 此博文系博主学习复盘,欢迎指正
本文专栏由 Hhy 维护。如果这篇文章曾带给你启发,请考虑关注我的 CSDN 博客或 GitHub 仓库以获取最新技术分享。



