vector的模拟实现

上一篇我们对vector一些常用的函数进行了讲解，本篇博客我们就对vector进行模拟实现，以便于我们更好地了解vector的使用以及对一些常见bug的认识

有了string类的模拟实现，vector的模拟实现我们上手起来就简单一点了：
首先为了和库里面的vector混淆视听，放入自己命名的空间里，并且根据vector的源码分析我们得出了三个成员变量：

分别是：
其实他们实质上都是指针，位置大概是这样的，遵循左闭右开的规则

_start
_finish
_endofstorage

这样一个简单的框架就构造出来了：
template是模板初阶我们学习过的，里面的T可以是char，int等任意类型

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

	private:
		iterator _start;
		iterator _finish;
		iterator _endofstorage;
	};
};

capacity和size

capacity就是endofstorage到start之间的可存储元素个数
size就是finish到start之间的有效元素个数

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

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

pushback尾插函数

尾插函数在很多地方可以复用，所以我们首先解决了尾插，为后面的函数进行模拟实现提供了基础：
插入首先就是要判断是否已满，所以我们先检查是否需要扩容，然后将当前finish位置的值置为x，finish的位置要往后移动一位

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

insert插入函数

同样的insert插入函数也需要复用，我们来解决它：
我们首先做的就是断言，pos一定是要在start和finish的区间之内的
当finish和endofstorage相等时就需要扩容，但是这里考虑到迭代器失效的问题我们就要记录pos和start原本之间的元素个数，然后再给start赋值
最后用while循环移动元素，移动完成后将pos位置的值置为x，同时finish位置往后移动一位即可

void insert(iterator pos, const T& x)
{
	assert(pos <= _finish);
	assert(pos >= _start);
	if (_finish == _endofstorage)
	{
		size_t len = pos - _start;
		reserve(capacity() == 0 ? 4 : capacity() * 2);
		_start = pos + len;//考虑到扩容之后迭代器失效的问题，所以记录位置
	}
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *(end);
		end--;
	}
	*pos = x;
	_finish++;
}

迭代器

迭代器是很常用的一个知识点，相信我们之前的学习中早已经熟悉了他的用法，很简单，但是我们需要对权限的放大有一个照顾，所以加上const

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

构造函数

构造函数主要用于初始化，他的作用很大也很常见，但是这里vector的构造函数可以用一个特殊的迭代器初始化

template <class InputIterator>
vector(InputIterator first, InputIterator last)
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstorage(nullptr)
{
	while (first != last)
	{
		push_back(*first);
		first++;
	}
}

还可以以这种方式，T（）默认就是0，和上面一样，直接用pushback尾插进去，当然这里的T（）其实是C++的一个匿名函数，通常我们所说匿名对象的生命周期只有一行，但是用const修饰后的匿名对象的生命周期会延长！

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

拷贝构造函数

拷贝构造我们直接用for循环解决，然后调用pushback ，很简单的

vector(const vector<T>& v)
{
	reserve(v.capacity());
	for (auto e : v)
	{
		push_back(e);
	}
}

析构函数

析构函数直接重拳出击了属于是（狗头）
用delete清空_start的空间，然后将其全部置为空

~vector()
{
	delete[] _start;
	_start = _finish = _endofstorage = nullptr;
}

swap函数

swap函数其实我们的用处不大，我们直接复用std标准库里的swap：

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

赋值操作符函数重载

也很简单，我们偷点懒用直接复用swap函数：
交换后返回*this即可

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

下标访问符重载

直接返回start下标指定下标的值即可，当然前提是这里的pos是要小于size的

T& operator[](size_t pos)
		{
			assert(pos < size());

			return _start[pos];
		}

		const T& operator[](size_t pos) const
		{
			assert(pos < size());

			return _start[pos];
		}

resize函数和reserve函数

其实我们可以将reserve先实现后直接将reserve复用再resize上，直接扩容
reserve扩容时只有n是大于原本的capacity时才会扩容，向前几篇博客所说的，不会进行缩容，然后我们记录有效元素个数sz=size（提前记录好是因为后面会进行delete释放原本start空间的操作），如果start不为空，就将start中的元素按照深拷贝的方式用for循环放入提前开辟好的tmp空间里，然后将tmp给予start，finish依旧时start+size，但是endofstorage变成了start+n

void reserve(size_t n)
{
	if (n > capacity())
	{
		T* tmp = new T[n];
		size_t sz = size();
		if (_start)
		{
			for (size_t i = 0; i < sz; i++)
			{
				tmp[i] = _start[i];
			}
			delete[] _start;
		}
		_start = tmp;
		_finish = _start + sz;
		_endofstorage = _start + n;
	}
}

resize函数的扩容我们就用reserve来实现，但是resize可以会初始化：

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++;
		}
	}
}

erase函数

这里有一个需要注意的点：
erase会返回被删除元素的下一个元素的迭代器！
断言我相信大家都是信手拈来了
我们将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;
}

好了，今天的分享到这里就结束了，感谢大家的支持！