C++STL---vector模拟实现-CSDN博客

本文链接：https://blog.csdn.net/weixin_73919606/article/details/139378270

通过上篇文章，我们知道vector的接口实际上和string是差不多的，但是他俩的内部结构却大不一样，vector内有三个成员变量：_start、_finish、_endofstorage:

_start指向容器的头元素，_finish指向有效元素末尾的元素，_endofstorage指向整个容器的尾。

而vector的迭代器就是typedef T*，也就是元素的指针。

所以我们在模拟之前就可以先做出一个小框架，为了不与库中的vector冲突，我们把他放在我们自己的命名空间中：

namespace CYF
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
	private:
		iterator _start;//指向容器的头
		iterator _finish;//指向有效数据的尾
		iterator _endofstorage;//指向容器的尾
	};
}

构造函数

构造函数1

这个是无参构造函数，我们将他所有的成员对象都制成空指针就行：

		//构造函数1
		vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_endofstorage(nullptr)
		{}

构造函数2

vector还支持使用一段迭代区间进行对象的构造。因为该迭代器区间可以是其他容器的迭代器区间，也就是说函数接收的迭代器的类型是不确定的，所以我们这里需要将构造函数设计为一个函数模板，在函数体内将该迭代区间的数据一个个尾插到容器当中即可：

		//构造函数2
		template<class InputIterator>//模板参数，因为迭代器区间可以是其他容器的迭代器
		vector(InputIterator first, InputIterator last)
			: _start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			while (first != last)//将迭代器区间在[first,last)中的数据一个个尾插到容器中
			{
				push_back(*first);
				first++;
			}
		}

构造函数3

vector还支持构造一种初始化有n个值为val的元素的对象。我们可以先使用reserve函数将容器的容量设为n，然后尾插n个值为val的数据到该对象即可：

		vector(size_t n, const T& val)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n);//调用reserve函数将容器容量设为n，可以避免效率降低
			for (size_t i = 0; i < n; i++)//尾插n个值为val的元素
			{
				push_back(val);
			}
		}

但是这个函数需要再实现两个重载函数：

vector(long n, const T& val)
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	reserve(n); 
	for (size_t i = 0; i < n; i++) 
	{
		push_back(val);
	}
}
vector(int n, const T& val)
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	reserve(n); 
	for (int i = 0; i < n; i++) 
	{
		push_back(val);
	}
}

这两个重载函数和他不同的就是第一个参数n的类型，如果没有这两个重载函数的话，我们调用下面的代码时，编译器就会优先和构造函数2匹配。

vector<int> v1(1, 3); //这里调用的是构造函数2

并且因为构造函数2当中对两个参数进行了解引用（即将int类型解引用）报错：

补充：若我们知道需要多少空间，我们最好先使用reserve函数一次性将空间开辟好，避免调用push_back函数时再增容，导致效率降低。

拷贝构造函数

传统写法1

这里仍然需要深拷贝，先开一段与拷贝对象大小相等的空间，然后将该对象内的元素一个个拷贝过来即可，最后记得更新成员对象的值：

		拷贝构造（传统写法1）
		vector(const vector<T>& v)
			:_start(nullptr)
			,_finish(nullptr)
			,_endofstorage(nullptr)
		{
			_start = new T[v.capacity()];//开辟一块和容器cipacity大小相同的空间
			for (size_t i = 0; i < v.size(); i++)//将v中数据拷贝过来,注意这里不能用memcpy
			{
				_start[i] = v[i];
			}
			_finish = _satrt + v.size();//有效数据的尾
			_endofstorage = _start + v.capacity();//整个容器的尾
		}

注意我们这里数据需要一个个拷贝过来，不能使用memcpy函数。若vector内部存储的是内置类型或者无需深拷贝的自定义类型时，可以使用memcpy函数，但是当vector内存储的数据是需要深拷贝的自定义类型的时候，使用memcpy就不行了。例如：我们拿存储的数据类型是string举例：

如图：我们vector对象内元素都是string类型，每个元素都指向自己的一个字符串。若我们使用memcpy函数的话，就会出现下面的情况：

memcpy会将每个string元素内成员变量的值原封不动地拷贝过去，也就导致了两个vector对象内的元素都指向同一组string元素。最后析构环节也就会导致内存错误。

而我们拷贝时采用string类的operator=的方式，采用的是深拷贝，最终的结果是这样：

就不会导致内存问题了。

传统写法2

这里我们直接调用reserve函数进行空间开辟，而后通过范围for将原有对象一个个尾插：

		//拷贝构造（传统写法2）
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(v.capacity());
			for (const auto& e : v)
			{
				push_back(e);
			}
		}

现代写法

这里我们将v1作为临时对象，通过构造函数构造出来。而后将v1与*this互换即可，经典的现代写法，无需多言：

		//拷贝构造（现代写法）
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			vector<T>v1(v.begin(),v.end());
			swap(v1);
		}

赋值运算符重载

传统写法

先判断是否为自己给自己赋值，若给自己赋值则不用做任何操作。若不是，则：先开辟一块和要拷贝对象capacity大小一样的空间，然后将数据一个个拷过来，最后更新成员对象的值：


		//赋值运算符重载函数(传统写法)
		vector<T>& operator=(const vector<T>& v)
		{
			if (this != &v)
			{
				delete[]_start;
				_start = new T[v.capacity()];
				_finish = _start + v.size();
				_endofstorage = _satrt + v.capacity();
				for (const auto& e : v)
				{
					push_back(e);
				}
			}
            return *this;
		}

现代写法

operator=的现代写法很巧妙，右值传参的时候使用传值传参而不是引用传参，这样就直接调用了vector的拷贝构造函数，然后用这个拷贝出来的局部对象和左值进行交换，就相当于做了赋值操作，而v是局部变量，在函数结束时会自动调用析构函数销毁。

//现代写法
vector<T>& operator=(vector<T> v) 
{
	swap(v); 
	return *this; //支持连续赋值
}

析构函数

先判断是否为空指针，若不是，将空间释放，再将成员变量全都置为nullptr：

		//析构函数
		~vector()
		{
			delete[]_start;
			_start = nullptr;
			_finish = nullptr;
			_endofstorage = nullptr;
		}

迭代器相关的函数（begin&&end）

我们上面讲过，vector的迭代器实际上就相当于存储数据类型的指针，begin()就是返回第一个元素地址，end()就是返回最后一个元素的下一个数据的地址：

		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对象实际上也就是使用指针遍历。并且实现了迭代器后，也就可以使用范围for，因为范围for在编译的时候，会自动替换为迭代器的形式。

关于容量和大小的函数

size && capacity

这里的size和capacity的算法跟string不同，string内直接就有两个成员变量表示size和capacity，而vector这里需要用_finish - _start和_endofstorage - _start分别得到：

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

reserve

1、当n大于对象当前的capacity时，将capacity扩大到n或大于n。
2、当n小于对象当前的capacity时，不用做任何操作

我们先判断n是否大于容量，若大于，就开辟一块容量为n的空间，将原来容器中的有效数据拷贝进去，再将原来的空间释放，记得更新容器内的成员变量：

void reserve(size_t n)
{
	if (n > capacity()) 
	{
		size_t sz = size(); //记录当前容器当中有效数据的个数
		T* tmp = new T[n]; //开辟一块可以容纳n个数据的空间
		if (_start) //判断是否为空容器
		{
			for (size_t i = 0; i < sz; i++) //拷贝数据
			{
				tmp[i] = _start[i];
			}
			delete[] _start; //释放原有空间
		}
		_start = tmp; //更新成员对象
		_finish = _start + sz; 
		_endofstorage = _start + n; 
	}
}

我们这里要注意要先记录元素的个数，否则我们最后更新_finish指针指向的时候，若调用size()函数，而size()函数是通过_finish-_start得到的，而此时_start已经指针指向已经改变，我们就会得到一个随机值，所以我们需要提前记录。

resize

1、当n大于当前的size时，将size扩大到n，扩大的数据为val，若val未给出，则默认为容器所存储类型的默认构造函数所构造出来的值。
2、当n小于当前的size时，将size缩小到n。

我们需要先判断n是否小于size，若小于，将_finish改变即可，若不小于，还需要判断是否需要增容，再将扩大的数据赋值为val即可：

		void resize(size_t n, const T& val = T())
		{
			if (n < size()) //当n小于size时
			{
				_finish = _start + n; 
			}
			else 
			{
				if (n > capacity()) 
				{
					reserve(n);
				}
				while (_finish < _start + n) 
				{
					*_finish = val;
					_finish++;
				}
			}
		}

在C++中内置类型也可以看作是一个类，也有自己的默认构造函数，所以val的缺省参数可以设为T()临时对象。

empty

判断对象是否为空：

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

有关修改对象的函数

push_back

先判断是否需要增容，再尾插，最后更新_finish的指向：

		void push_back(const T& x)
		{
			if (_finish==_endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);
			}
			*_finish = x;
			_finish++;
		}

pop_back

判断对象是否为空，不为空将_finish--即可：

		void pop_back()
		{
			assert(!empty());//容器不能为空
			_finish--;
		}

insert

我们需要先判断pos是否合法，再判断是否需要增容，然后将pos后的元素都向后移一位，将x插在pos的位置，最后将_finish++：

		void insert(iterator pos, const T& x)
		{
			if (pos <= _finish)//判断pos是合法
			{
				size_t n = pos - _start;//记录pos和_start之间的间隔
				if (_finish == _endofstorage)
				{
					size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
					reserve(newcapacity);
				}
				pos = _start + n;//根据记录的间隔数算出pos
				iterator i = _finish;
				while (i != pos)
				{
					*(i + 1) = *i;
					i--;
				}
				*pos = x;
				_finish++;
			}
		}

提示：这里我们需要提前记录pos和_start之间的间隔，通过间隔确定增容后的pos的指向，否则pos还是指向原来已经被释放的空间。（我自己在写的时候就出现了这样的错误）

erase

先判断对象不能为空，删除时将pos后面的数据统一前移一位，覆盖掉pos的数据，返回值还为pos，即删除元素的下一个元素的位置：

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

swap

我们调用库中的swap函数将两个对象中的成员变量交换即可（这样就相当于交换了两个对象内部指针的指向，不耗费太多资源，若我们直接调用swap交换两个对象，若遇见例如string这样的对象，swap交换时做的全都是深拷贝操作，太耗费资源了，所以我们只交话两个对象内部的成员变量即可）：

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

operator[ ]

通过下标访问vector内元素，直接返回数据即可：

		T& operator[](size_t i)
		{
			if(i<size())
			{
				return *(_start + i);
			}
		}

		const T& operator[](size_t i)const
		{
			if (i < size())
			{
				return *(_start + i);
			}
		}

最后贴上整体代码：

#pragma once
#include<iostream>
#include<cassert>

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

		//构造函数1
		vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_endofstorage(nullptr)
		{}
		//构造函数2
		template<class InputIterator>//模板参数，因为迭代器区间可以是其他容器的迭代器
		vector(InputIterator first, InputIterator last)
			: _start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			while (first != last)//将迭代器区间在[first,last)中的数据一个个尾插到容器中
			{
				push_back(*first);
				first++;
			}
		}

		//构造函数3
		vector(size_t n, const T& val)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n);//调用reserve函数将容器容量设为n，可以避免效率降低
			for (size_t i = 0; i < n; i++)//尾插n个值为val的元素
			{
				push_back(val);
			}
		}

		//拷贝构造（传统写法1）
		//vector(const vector<T>& v)
		//	:_start(nullptr)
		//	,_finish(nullptr)
		//	,_endofstorage(nullptr)
		//{
		//	_start = new T[v.capacity()];//开辟一块和容器cipacity大小相同的空间
		//	for (size_t i = 0; i < v.size(); i++)//将v中数据拷贝过来,注意这里不能用memcpy
		//	{
		//		_start[i] = v[i];
		//	}
		//	_finish = _satrt + v.size();//有效数据的尾
		//	_endofstorage = _start + v.capacity();//整个容器的尾
		//}

		//拷贝构造（传统写法2）
		//vector(const vector<T>& v)
		//	:_start(nullptr)
		//	, _finish(nullptr)
		//	, _endofstorage(nullptr)
		//{
		//	reserve(v.capacity());
		//	for (const auto& e : v)
		//	{
		//		push_back(e);
		//	}
		//}

		//拷贝构造（现代写法）
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			vector<T>v1(v.begin(),v.end());
			swap(v1);
		}

		赋值运算符重载函数(传统写法)
		//vector<T>& operator=(const vector<T>& v)
		//{
		//	if (this != &v)
		//	{
		//		delete[]_start;
		//		_start = new T[v.capacity()];
		//		_finish = _start + v.size();
		//		_endofstorage = _satrt + v.capacity();
		//		for (const auto& e : v)
		//		{
		//			push_back(e);
		//		}
		//	}
		//	return *this;
		//}

		//赋值运算符重载函数(现代写法)
		vector<T>& operator=(const vector<T>& v)
		{
			if (this != &v)
			{
				vector<T> v1(v.begin(),v.end());
				swap(v1);
			}
			return *this;
		}


		//析构函数
		~vector()
		{
			delete[]_start;
			_start = nullptr;
			_finish = nullptr;
			_endofstorage = nullptr;
		}

		//迭代器相关函数
		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}
		const_iterator begin()const
		{
			return _start;
		}
		const_iterator end()const
		{
			return _finish;
		}

		//容量和大小相关函数
		size_t size()const
		{
			return _finish - _start;
		}
		size_t capacity()const
		{
			return _endofstorage - _start;
		}
		void reserve(size_t n)
		{
			if (n >= capacity())
			{
				iterator _start_ = new T[n];
				_finish = _start_ + size();
				_endofstorage = _start_ + n;
				size_t i = 0;
				while (_start_ + i != _finish)
				{
					_start_[i] = _start[i];
					i++;
				}
				delete[]_start;
				_start = _start_;
				_start_ = nullptr;
			}
		}

		//void resize(size_t n, const T& val = T())
		//{
		//	if (n <= size())
		//	{
		//		_finish = _start + n - 1;//这时候只会size，不会改变capacity
		//	}
		//	else if (n > size() && n <= capacity())
		//	{
		//		size_t more = n - size();
		//		while (more > 0)
		//		{
		//			*_finish = val;
		//			_finish++;
		//			more--;
		//		}
		//	}
		//	else
		//	{
		//		reserve(n);
		//		while (_finish != _start + n)
		//		{
		//			*_finish = val;
		//			_finish++;
		//		}
		//	}
		//}

		void resize(size_t n, const T& val = T())
		{
			if (n < size()) //当n小于当前的size时
			{
				_finish = _start + n; //将size缩小到n
			}
			else //当n大于当前的size时
			{
				if (n > capacity()) //判断是否需要增容
				{
					reserve(n);
				}
				while (_finish < _start + n) //将size扩大到n
				{
					*_finish = val;
					_finish++;
				}
			}
		}

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

		//修改容器内容相关函数
		void push_back(const T& x)
		{
			if (_finish==_endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);
			}
			*_finish = x;
			_finish++;
		}
		void pop_back()
		{
			assert(!empty());//容器不能为空
			_finish--;
		}

		void insert(iterator pos, const T& x)
		{
			if (pos <= _finish)//判断pos是合法
			{
				size_t n = pos - _start;
				if (_finish == _endofstorage)
				{
					size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
					reserve(newcapacity);
				}
				pos = _start + n;
				iterator i = _finish;
				while (i != pos)
				{
					*(i + 1) = *i;
					i--;
				}
				*pos = x;
				_finish++;
			}
		}

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

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

		//访问容器相关函数
		T& operator[](size_t i)
		{
			if(i<size())
			{
				return *(_start + i);
			}
		}

		const T& operator[](size_t i)const
		{
			if (i < size())
			{
				return *(_start + i);
			}
		}

	private:
		iterator _start;//指向容器的头
		iterator _finish;//指向有效数据的尾
		iterator _endofstorage;//指向容器的尾
	};
}

以上就是这篇文章的全部内容，谢谢大家！！