vector的模拟实现

最新推荐文章于 2024-10-04 13:19:44 发布
最新推荐文章于 2024-10-04 13:19:44 发布
阅读量274 收藏 9
点赞数 11
分类专栏： C++ 文章标签： vector 模拟实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63319459/article/details/132022472
版权
文章介绍了如何模拟实现C++中的STL容器vector，包括其基础框架、成员变量如start、finish、end_of_storage的含义以及构造函数和析构函数的实现。文中详细阐述了push_back、reserve、insert、erase和resize等常用函数的实现逻辑，特别关注了迭代器失效和内存管理的问题。此外，还讨论了vector的拷贝构造和赋值运算符重载，确保了深拷贝的正确性。
摘要由CSDN通过智能技术生成

文章目录

vector的模拟实现

先了解vector底层的成员变量的表示的含义

在这里插入图片描述

vector成员变量由三个start、finish、end_of_storage三个迭代器组成，分别表示不同的迭代器地址

注意：capacity的初始值和初始化有关，std中vector的初始化如果是默认构造，capacity默认为0，如果是vector<int> v(10,1)，那么capacity初始值为10，初始化vector对象的增加数据个数便为capacity的初始值。

vector的基础框架

将我们模拟实现的基础框架放在命名空间why中，主要是对于成员变量、构造函数、析构函数、push_back、reserve的实现

在这里插入图片描述

注意：reserve中使用old_size变量提前得到当前数据个数，是防止扩容后迭代器失效，能正确的更新_finish,更新成员变量都是通过以_start为基准的偏移量实现，_finish=_start+size(),_end_of_storage=_start+capacity()

namespace why
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}
		//构造函数
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{}
		//析构函数
		~vector()
		{
			if (_start)
			{
				//如果不为空的话，那么就进行释放_start的空间，并指向空nullptr
				delete[] _start;
				_start = _finish = _end_of_storage = nullptr;
			}
		}

		void push_back(const T& x)
		{
			//添加元素，先进行判定当前容量
			if (_finish == _end_of_storage)
			{
				//需要进行扩容
				size_t new_capacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(new_capacity);
			}
			*_finish = x;
			++_finish;
		}

		void reserve(size_t n)
		{
			//判断是否需要扩容
			if (n > capacity())
			{
				//进行扩容
				//防止迭代器失效
				size_t old_size = size();
				T* tmp = new T[n];
				if (_start)
				{
					//如果不为空
					memcpy(tmp, _start, sizeof(T) * old_size);
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + old_size;
				_end_of_storage = _start + n;
			}
		}

		//得到pos下标的数值
		T& operator[](size_t pos)
		{
			return _start[pos];
		}

		const T& operator[](size_t pos) const  //对于静态变量
		{
			return _start[pos];
		}

		size_t capacity() const
		{
			return _end_of_storage - _start;
		}
		size_t size() const
		{
			return _finish - _start;
		}
	private:
		iterator _start;//表示开头地址
		iterator _finish;//表示当前结尾元素的地址
		iterator _end_of_storage;//表示当前vector最大容量的地址
	};
}

常用函数的实现

常用的函数实现，比如insert、erase、resize等，以此来了解stl中vector函数实现机制，更好的理解vector

insert的实现

在pos位置上插入val，要考虑迭代器失效的问题，所以在扩容之前就要得到相对位置len，然后得到扩容后的pos位置
在这里插入图片描述

iterator insert(iterator pos, const T& x)
{
	assert(pos >= _start && pos <= _finish);

	if (_finish == _end_of_storage)
	{
		size_t len = pos - _start;

		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
		// 解决pos迭代器失效问题
		pos = _start + len;
	}

	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}
	*pos = x;
	++_finish;

	return pos;
}

erase的实现

erase的实现比较简单，就是在指定pos位置的后一位，统一向前移动数组，--_finsh,返回pos的地址

在这里插入图片描述

iterator erase(iterator pos)
{
	assert(pos >= _start && pos < _finish);

	iterator it = pos + 1;
	while (it != _finish)
	{
		*(it - 1) = *it;
		++it;
	}

	--_finish;

	return pos;
}

resize的实现

对于容器来讲，先实现reserve就能方便实现其他内容，因为很多接口的底层中包含reserve，我们先实现resize
在这里插入图片描述

void resize(size_t n, const T& val = T())
{
	if (n < size())
	{
		_finish = _start + n;  //直接更新_finish
	}
	else
	{
		reserve(n);//判断是否需要扩容
		//从_finish位置开始添加元素
		while (_finish != _start + n) 
		{
			*_finish = val;
			++_finish;
		}
	}
}

vector的拷贝构造

对于一些自定义类型，如果涉及到资源管理（开辟空间，比如string，会开辟char*的空间），当进行拷贝构造的时候，我们需要的是深拷贝，而不是简单的值拷贝

vector(const vector<T>& v)
{
	_start = new T[v.capacity()];
	//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();
	_end_of_storage = _start + v.capacity();
}

		/// <summary>
		/// 这是另一种拷贝构造的方法，复用push_back
		/// </summary>
		/// <param name="v"></param>
vector(const vector<T>& v)
	:_start(nullptr)
	, _finish(nullptr)
	, _end_of_storage(nullptr)
{
	reserve(v.capacity());
	for (auto e : v)
	{
		push_back(e);
	}
}

operator= 函数

考虑到自定义对象，所以我们还是使用深拷贝的方式。使用现代的手法，swap交换成员变量

void swap(vector<T>& v)
{
    //交换地址即可，这样给了当前对象，然后v和当前对象没有指向同一块空间，不会出现析构两次的问题
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_end_of_storage, v._end_of_storage);
}

// v1 = v2
vector<T>& operator=(vector<T> v)  //传值即可，会调用拷贝构造，深拷贝到得到一块新空间，但是数据是一样的，然后将这个空间的数据通过swap与当前self对象进行交换，完毕之后，不会改变实参vector对象的的成员变量，只是改变了拷贝构造之后的v的成员变量
{
	swap(v);

	return *this;
}

函数测试

void test11()
{
	why::vector<string> v;
	v.push_back("123");
	v.push_back("123");
	v.push_back("123");
	v.push_back("123");
	for (auto c : v)
	{
		cout << c << " ";
	}
	cout << endl;
	why::vector<string> v1(v);

	for (auto c : v1)
	{
		cout << c << " ";
	}
	cout << endl;
	why::vector<string> v2;
	v2 = v;
	for (auto c : v2)
	{
		cout << c << " ";
	}
	cout << endl;
}
int main()
{
	test11();
	return 0;
}

在这里插入图片描述

完整模拟实现代码

namespace why
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}
		//构造函数
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{}
		~vector()
		{
			if (_start)
			{
				//如果不为空的话，那么就进行释放_start的空间，并指向空nullptr
				delete[] _start;
				_start = _finish = _end_of_storage = nullptr;
			}
		}

		void resize(size_t n, const T& val = T())
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);

				while (_finish != _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}
		iterator insert(iterator pos, const T& x)
		{
			assert(pos >= _start && pos <= _finish);

			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;

				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);

				// 解决pos迭代器失效问题
				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 && pos < _finish);

			iterator it = pos + 1;
			while (it != _finish)
			{
				*(it - 1) = *it;
				++it;
			}

			--_finish;

			return pos;
		}
		//vector(size_t n, const T& val = T())
		//{
		//	resize(n, val);
		//}

		//vector(int 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;
		//	}
		//}
		//
		//深拷贝
		//vector(const vector<T>& v)
		//{
		//	_start = new T[v.capacity()];
		//	//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();
		//	_end_of_storage = _start + v.capacity();
		//}
		void push_back(const T& x)
		{
			//添加元素，先进行判定当前容量
			if (_finish == _end_of_storage)
			{
				//需要进行扩容
				size_t new_capacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(new_capacity);
			}
			*_finish = x;
			++_finish;
		}
		vector(const vector<T>& v)
		{
			_start = new T[v.capacity()];
			//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();
			_end_of_storage = _start + v.capacity();
		}
		void reserve(size_t n)
		{
			//判断是否需要扩容
			if (n > capacity())
			{
				//进行扩容
				//防止迭代器失效
				size_t old_size = size();
				T* tmp = new T[n];
				if (_start)
				{
					//如果不为空
					memcpy(tmp, _start, sizeof(T) * old_size);
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + old_size;
				_end_of_storage = _start + n;
			}
		}
		/// <summary>
		/// 这是另一种拷贝构造的方法，复用push_back
		/// </summary>
		/// <param name="v"></param>
		//vector(const vector<T>& v)
		//	:_start(nullptr)
		//	, _finish(nullptr)
		//	, _end_of_storage(nullptr)
		//{
		//	reserve(v.capacity());
		//	for (auto e : v)
		//	{
		//		push_back(e);
		//	}
		//}
		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_end_of_storage, v._end_of_storage);
		}

		// v1 = v2
		vector<T>& operator=(vector<T>& v)
		{
			swap(v);

			return *this;
		}
		//得到pos下标的数值
		T& operator[](size_t pos)
		{
			return _start[pos];
		}

		const T& operator[](size_t pos) const  //对于静态变量
		{
			return _start[pos];
		}

		size_t capacity() const
		{
			return _end_of_storage - _start;
		}
		size_t size() const
		{
			return _finish - _start;
		}
	private:
		iterator _start;//表示开头地址
		iterator _finish;//表示当前结尾元素的地址
		iterator _end_of_storage;//表示当前vector最大容量的地址
	};
}
小王学代码
关注
专栏目录
Vector模拟实现
2301_77272486的博客
04-27 930
模拟实现Vector容器，深入了解Vector的底层运行原理
c++ vector模拟实现代码
08-25
下面是一个简化的`vector`模拟实现： ```cpp template class vector { public: typedef T* iterator; // 构造函数 vector() : start(nullptr), finish(nullptr), end_of_storage(nullptr) {} vector(size_t n,...
【vector的模拟实现】
Willing_hope的博客
08-06 197
1、构造函数 //无参构造 vector() :_start(nullptr), _finish(nullptr), _endofstorage(nullptr) {} //拷贝构造1 vector(const vector<T>&v) { _start = new T[v.capacity()]; _finish = _start + v.size(); _endofstorage = _start + v.capacity();
vector模拟实现
.
06-12 3006
vector的模拟实现
【C++】vector模拟实现
VHhhbb的博客
07-15 1069
【C++】vector模拟实现
C++ vector模拟实现
Wzs040810的博客
01-10 3717
C++ STL vector模拟实现
[C++]vector模拟实现
weixin_52345097的博客
03-05 1440
C++vector模拟实现
C++ [STL之vector模拟实现]
ARMCSKGT的博客
05-27 5315
vector是STL容器容器之一，其底层实现类似于数据结构顺序表，相当于string来说得益于泛型模板的加持使得vector可以变为任何类型，且是可以动态扩容，堪称大号数组！在vector的实现中，有许多值得我们学习的细节，接下来将为大家一 一介绍！
【C++初阶】vector模拟实现
weixin_74967884的博客
09-19 1894
本章节主要介绍了vector的模拟实现，从分模块介绍，再到最后的整合。
【C++】—— vector模拟实现
LH__1314的博客
10-04 1705
编译器在编译时，认为T已经实例化成了int，对于两个int类型，编译器就会选择更为匹配的模版。而不只是简单的浅拷贝了。​ vector成员变量，和顺序表的成员变量有所不同，不再是指针、size和capacity了，而是迭代器 start、finish和end_of_storage。​ 使用迭代器区间进行初始化，这里不一定是vector的迭代器，所以写成模板。​ 赋值运算符重载，这个编译器自动生成的是浅拷贝，我们需要写一个深拷贝的。​ 这里，扩容之后还用一个迭代器失效问题，需要重新给pos赋值。
C++ STL vector 模拟实现
qq_63943454的博客
08-10 1358
我们之前学习了，vector的使用，Vector在功能上就是我们数据结构阶段实现的顺序表基本一致，但是Vector在成员框架上与顺序表有所不同，且Vector使用类和对象封装支持模板泛型。
vector 模拟实现
03-20
在本模拟实现中，我们将探讨如何根据《C++ Primer》一书中的指导，创建一个基本的`vector`类，关注其核心功能，如内存管理、动态增长和STL（标准模板库）接口的兼容性。以下是对这个模拟实现的一些关键知识点的详细...
MATLAB公路裂缝检测系统面板GUI.zip
11-02
圣诞树
Flask-2.1.3.tar.zip
最新发布
11-02
Flask-2.1.3.tar.zip
Flask-0.12.4.tar.zip
11-02
Flask-0.12.4.tar.zip
基于LangChain的QQ邮件智能收发工具
11-02
基于LangChain的QQ邮件智能收发工具
Flask-1.0.4-py2.py3-none-any.zip
11-02
Flask-1.0.4-py2.py3-none-any.zip
江协科技0.96寸OLED驱动函数（HAL库移植）
11-02
江协科技0.96寸OLED驱动函数（HAL库移植）
flask-2.3.3-py3-none-any.zip
11-02
flask-2.3.3-py3-none-any.zip
C++中简易动态内存管理的vector模拟实现
理解构造函数与析构函数的工作原理对于实现一个安全且有效的vector模拟至关重要。 知识点四：拷贝构造函数和赋值操作符重载 拷贝构造函数用于创建一个新对象作为现有对象的副本，而赋值操作符重载用于给已经存在的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小王学代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值