《C++深度解构07》手撕 vector —— 从底层三指针架构到迭代器失效彻底吃透

目录

    • [一、 结构与底层骨架设计](#一、 结构与底层骨架设计)
      • [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.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 赋值重载函数)
    • [三、 实战踩坑实录:从编译报错到内存崩溃](#三、 实战踩坑实录:从编译报错到内存崩溃)
      • [坑位 1:拷贝构造采用`memcpy` 引发的"双重析构"惨案](#坑位 1:拷贝构造采用memcpy 引发的“双重析构”惨案)
      • [坑位 2:匿名对象与常引用权限(`const T& val = T()`)](#坑位 2:匿名对象与常引用权限(const T& val = T()))
      • [坑位 3:`const` 对象的权限传递与 E0349 报错](#坑位 3:const 对象的权限传递与 E0349 报错)
    • [四、 进阶思考:还能怎么打磨?](#四、 进阶思考:还能怎么打磨?)

📌 相关专栏与源码导航:


前言 :在上一篇《手撕 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还是原来的旧地址,两地址相减无法得出相对距离。


为了方便后续测试,我们在这里写一个函数模板(参数类型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 末尾注释):

    cpp 复制代码
    int 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) 时:

  1. 内部调用 v.capacity() 提前开空间,如果 capacity() 成员函数后面漏写了 const 修饰(size_t capacity() const),const 对象 v 就无法调用它,直接报错。
  2. 同理,如果后续在拷贝构造或只读场景下使用 v[i] 访问元素,必须同时提供 const T& operator[](size_t n) const 重载,否则只有普通版 T& operator[](size_t n) 时,编译器会直接抛出 E0349: 没有与这些操作数匹配的 "[]" 运算符。

四、 进阶思考:还能怎么打磨?

这版代码已经能顺利通过所有基础与深拷贝测试,还有两个非常有意思的进阶细节值得继续深挖:

  1. 构造函数重载冲突 :当同时存在 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) 巧妙化解了这个问题。
  2. 外部迭代器失效规范 :目前 insert 和 erase 在修正后返回了更新后的迭代器 iterator,调用方在执行删除或插入后,必须用返回值重新接收(it = v.erase(it);),绝不能直接继续使用旧的迭代器。

"不必急于证明自己,沉下心走好脚下的每一步,时间自会给出答案。"
Crafted with passion by Hhy
当前更新时间:{{ 2026 / 11 / 16 }} | 此博文系博主学习复盘,欢迎指正


本文专栏由 Hhy 维护。如果这篇文章曾带给你启发,请考虑关注我的 CSDN 博客或 GitHub 仓库以获取最新技术分享。

相关推荐
风落青芜15 分钟前
链式二叉树的实现与基本操作
c语言·开发语言·数据结构·算法
艾莉丝努力练剑1 小时前
【QT】系统相关:TCP的API介绍
开发语言·前端·c++·人工智能·qt·学习·tcp/ip
青少儿编程课堂1 小时前
蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:中国剩余定理解析
c++·python·算法·bfs·信息学竞赛
wo_jack2 小时前
C++ 入门笔记(十八):list 进阶 —— const 迭代器、operator-> 与 clear 的坑
数据结构·c++·面试·stl·list
wuxianda10302 小时前
Swift 项目用 Xcode 脚手架起步:默认工程结构和依赖组合为什么会被识别成同源
开发语言·xcode·swift·4.3a·appstore审核
ShineWinsu2 小时前
对于Qt:QVBoxLayout常见属性以及方法的解析
开发语言·数据库·c++·qt·gui·客户端·布局管理器
Sarvartha2 小时前
反射综合案例:SQL 语句生成
java·开发语言
ShineWinsu13 小时前
对于Qt:QFormLayout常见属性以及方法的解析
开发语言·c++·qt·面试·客户端·表单·qformlayout
kyle~14 小时前
嵌入式 SoC 系统
linux·c++·嵌入式·计算系统