文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
社区首页 >专栏 >揭开 C++ vector 底层面纱：从三指针模型到手写完整实现

揭开 C++ vector 底层面纱：从三指针模型到手写完整实现

作者头像
草莓熊Lotso
发布于 2025-10-29 13:07:29
发布于 2025-10-29 13:07:29
1050
举报
文章被收录于专栏：C++/LinuxC++/Linux

🔥草莓熊Lotso：个人主页

❄️个人专栏：《C++知识分享》《Linux 入门到实践：零基础也能懂》

✨生活是默默的坚持，毅力是永久的享受

🎬博主简介：

前言：

C++ 标准库中的 vector 堪称 “最常用容器”，它兼具数组的随机访问效率与动态扩容的灵活性，是开发和刷题的 “利器”。但很多开发者只停留在 “会用” 层面，对其底层实现原理一知半解。本文将从内存管理核心机制讲起，手把手带你实现一个功能完整的简化版 vector，涵盖构造 / 析构、扩容策略、迭代器设计等核心模块，让你彻底吃透这个 “动态数组” 的工作逻辑。

一. vector 底层核心：三指针控制内存

vector 的本质是动态管理连续内存的容器，其核心通过三个指针（迭代器）控制内存块：

  • _start ：指向内存块的起始位置（第一个元素的地址）；
  • _finish：指向有效元素的末尾（最后一个元素的下一位）；
  • _end_of_storage：指向内存块的末尾（容量的边界）。
代码语言：javascript
复制
namespace Lotso
{
	template<class T>
	class vector
	{
public：
	    //typedef T* iterator;
	    using iterator = T*;
	    using const_iterator = const T*;
private:
		iterator _start = nullptr;//数据起始位置
		iterator _finish = nullptr;//有效数据
		iterator _end_of_storage = nullptr;//空间
	};
}

通过这三个指针，可直接计算：

  • 有效元素个数（size）：_finish - _start
  • 容量（capacity）：_end_of_storage - _start
代码语言：javascript
复制
public：
size_t capacity() const
{
	return _end_of_storage - _start;
}

size_t size() const
{
	return _finish - _start;
}

二. 迭代器设计：连续内存的 “天然优势”

  • vector的迭代器是对原生指针的封装，支持随机访问等操作，是很好用的
迭代器类型定义：
代码语言：javascript
复制
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：
代码语言：javascript
复制
namespace Lotso
{
	void Print(const vector<int>& 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<int> 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的基础框架

--我们这里主要介绍一下无参构造，其它的就不多讲了

代码语言：javascript
复制
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。
代码语言：javascript
复制
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;
			}*///string,vector这种深拷贝的会出错
				
			if (_start)
			{
				for (size_t i = 0; i < sz; i++)
				{
					//tmp[i] = _start[i];//swap更好用
					std::swap(tmp[i], _start[i]);
				}
				delete[] _start;
			}

			_start = tmp;
			_finish = _start + sz;
			_end_of_storage = _start + n;
		}
	}

核心：reserve 只管理内存，不创建或销毁元素，适合提前扩容以优化性能。

3.2.2 resize 改变size：可能初始化或销毁元素
  • resize(n，val) 会将 size 调整为 n ，多余元素销毁，不足则用 val 填充。
代码语言：javascript
复制
void resize(size_t n, T val = T())
	{
		if (n < size())
		{
			_finish = _start + n;
		}
		else
		{
			reserve(n);
			while (_finish < _start + n)
			{
				*_finish = val;
				++_finish;
			}
		}
	}

3.3 元素操作：增删查改的实现细节

3.3.1 尾插(push_back)与尾删(pop_back)：

尾插和尾删是 vector 最高效的操作（O (1)），只需检查容量并构造元素，销毁元素：

代码语言：javascript
复制
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)：

代码语言：javascript
复制
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 []

提供数组式访问，不做越界检查（高效）

代码语言：javascript
复制
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 返回下一个有效迭代器（见下方示例）：
代码语言：javascript
复制
// 正确删除偶数元素
auto it = v.begin();
while (it != v.end()) {
    if (*it % 2 == 0) {
        it = v.erase(it); // 用返回值更新迭代器
    } else {
        ++it;
    }
}

--下面这些也可以参考一下

代码语言：javascript
复制
	void test_vector2()
	{
		Lotso::vector<int> 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<int> 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<int> 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 和拷贝构造均用移动 / 拷贝构造函数迁移元素，避免了这一问题。

代码语言：javascript
复制
vector(const vector<T>& v)
	{
		reserve(v.capacity());
		for (const auto& e : v)
		{
			push_back(e);
		}
	}

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;
			}*///string,vector这种深拷贝的会出错
				
			if (_start)
			{
				for (size_t i = 0; i < sz; i++)
				{
					//tmp[i] = _start[i];//swap更好用
					std:swap(tmp[i], _start[i]);
				}
				delete[] _start;
			}

			_start = tmp;
			_finish = _start + sz;
			_end_of_storage = _start + n;
		}
	}

补充接口：

代码语言：javascript
复制
    vector(initializer_list<T> il)
    {
	    reserve(il.size());
	    for (const auto& e : il)
	    {
		    push_back(e);
	    }
    }

         //传统写法
		/*vector(const vector<T>& v)
		{
			reserve(v.capacity());
			for (const auto& e : v)
			{
				push_back(e);
			}
		}*/

		/*vector<T>& operator=(const vector<T>& v)
		{
			if (this != &v)
			{
				clear();

				reserve(v.capacity());
				for (const auto& e : v)
				{
					push_back(e);
				}
			}
			return *this;
		}*/


	    vector(size_t n, const T& val = T())
	    {
		    reserve(n);
		    for (size_t i = 0; i < n; i++)
		    {
			    push_back(val);
		    }
	    }

	    //暂时解决类型错误匹配到下面那个模板的问题
	    vector(int n, const T& val = T())
	    {
	    	reserve(n);
		    for (int i = 0; i < n; i++)
		    {
		    	push_back(val);
		    }
	    }

		//现代写法
		//函数模板--不一定是vector的迭代器，也可以是其它的迭代器
		template <class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			//reserve(last - first);//有的迭代器不行
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_end_of_storage, v._end_of_storage);
		}

		vector(const vector<T>& v)
		{
			vector<T> tmp(v.begin(), v.end());
			swap(tmp);
		}

		vector<T>& operator=( vector<T> tmp)
		{
			swap(tmp);
			return *this;
		}


		void clear()
		{
			_finish = _start;
		}

		bool empty() const
		{
			return _start == _finish;
		}

结尾：

往期回顾：

《吃透 C++ vector：从基础使用到核心接口实战指南》

结语：通过手写 vector，我们不仅理解了其底层的三指针模型、扩容策略和迭代器设计，更能在实际开发中规避迭代器失效、浅拷贝等陷阱。掌握这些原理，无论是使用标准库 vector 还是设计自定义容器，都会更加得心应手。

✨把这些内容吃透超牛的！放松下吧✨ ʕ˘ᴥ˘ʔ づきらど

本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2025-10-10，如有侵权请联系 cloudcommunity@tencent.com 删除
指针
c++
vector
模型
内存

本文分享自 作者个人站点/博客 前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

指针
c++
vector
模型
内存
评论
登录后参与评论
0 条评论
热度
最新
登录 后参与评论
推荐阅读
目录
  • 前言：
  • 一. vector 底层核心：三指针控制内存
  • 二. 迭代器设计：连续内存的 “天然优势”
    • 迭代器类型定义：
  • 三. 核心接口实现：从构造到析构的内存管理
    • 3.1 构造与析构：vector的基础框架
    • 3.2 容量管理：reserve 与 resize 的区别
      • 3.2.1 reserve：仅扩容，不初始化元素
      • 3.2.2 resize 改变size：可能初始化或销毁元素
    • 3.3 元素操作：增删查改的实现细节
      • 3.3.1 尾插(push_back)与尾删(pop_back)：
      • 3.3.2 插入（insert）：中间插入的性能代价
      • 3.3.3 访问元素：operator []
  • 四. 避坑指南：vector 使用的 3 个核心陷阱
    • 4.1 迭代器失效：扩容与删除的 “隐形炸弹”
    • 4.2 浅拷贝风险：自定义类型必须深拷贝
  • 结尾：
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2025 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论