C++ vector模拟实现

vector接口总结

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

		iterator begin();
		iterator end();

		const_iterator begin()const;
		const_iterator end()const;

		vector();
		template <class InputIterator>
		vector(InputIterator first, InputIterator last);//迭代器区间构造
		vector(int  n, const T& val = T());
		vector(size_t  n, const T& val = T())
		vector(initializer_list<T> il);
		//拷贝构造
		vector(const vector<T>& v);
		//析构函数
		~vector();

		size_t capacity()const;
		size_t size() const;

		T& operator[](size_t pos);
		vector<T>& operator= (vector<T> v);

		void reserve(size_t n);
		void push_back(const T& val = T());
		bool empty();
		void pop_back();
		void insert(iterator pos, const T& val = T());
		void erase(iterator pos);
		void swap(vector<T>& val);
		void resize(size_t n, const T& val = T());

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

构造函数

1. 构造函数可以支持无参数构造，即我们将自定义变量设置为空指针。

vector()
	:_start(nullptr)
	,_finish(nullptr)
	,_endofstorage(nullptr)
{}

也可以直接使用缺省参数在声明处直接给空指针。

private:
	iterator _start = nullptr;
	iterator _finish = nullptr;
	iterator _endofstorage = nullptr;

2. 构造函数还支持迭代器区间构造，该构造函数的参数可以是任意容器的迭代器区间。所以我们要将这个构造函数写成模板。 我们区间的数据一个一个插入到容器中。

//迭代器区间构造
template <class InputIterator>
vector(InputIterator first, InputIterator last)
//first指向区间的开始位置，last指向区间的末尾
{
	while (first != last)
	{
		push_back(*first);
		first++;
	}
}

3. 这里还有一种构造，使用reserve开辟空间再将数据一个一个尾插入容器中。

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

4. 库中c++11还提供了一种构造方法，使用initializer_list构造函数。 initializer_list是一种标准库类型，用于表示某种特定类型的值的数组。initializer_list 支持迭代器，我们可以理解为initializer_list中有两个指针一个指向数组的开始、另一个指向空间的结束。
   initializer_list类型中有size()函数和迭代器，因此我们可以直接使用范围for尾插入数据到容器中。

vector(initializer_list<T> il)
{
	reserve(il.size());
	for (auto& e : il)
	{
		push_back(e);
	}
}

说到initializer_list就不得不提到隐式类型转换。
c++11中提供了一种写法：可以直接使用数组构造对象。首先数组先构造成initializer_list对象，再用 initializer_list对象构造vector对象，其中就使用到了隐式类型转换。

//使用initializer_list构造函数，可以直接赋值初始化。
vector<int>  v1 = { 1,2,3,4,5,6,7,8,9 };// 构造 + 拷贝 ->优化 直接构造

隐式类型转换会将原本的构造函数和拷贝构造直接优化成直接构造函数。在使用引用的情况下，不会优化。原因是类型转换会产生临时变量，而临时变量具有常性 ，要用到const修饰。

 //隐式类型转换
 string s1 = "abcdefg";// 构造 + 拷贝 ->优化 直接构造
 const  string& s2 = "abcdefg";//构造临时对象，引用的是临时对象

initializer_list文档参考

拷贝构造

说到拷贝构造，老生常谈的就是深浅拷贝的问题。这里我们直接提供现代写法。
使用范围for对容器遍历，将数据尾插入容器中。

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

析构函数

析构函数直接释放空间，并将各个成员变量置空。

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

赋值运算符重载

赋值运算符参数没有使用引用传参，而是使用拷贝构造。拷贝出来的容器直接与this左值进行交换，就相当于容器v赋值给了this。

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

迭代器

迭代器有两个版本

typedef T* iterator;
typedef const T* const_iterator;

begin 和 end

容器begin函数返回的是容器的首地址，end()自然是返回容器的末尾处。

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

const下的begin 和 end

const下的begin和end返回的值还是首地址和末尾处，只是在const修饰下迭代器只能够读取数据不能修改。

const_iterator begin() const
{
	return _start;
}

const_iterator end() const
{
	return _finish;
}

容器大小和容量

容器中有三个自定义成员变量，了解清楚这三个成员变量就可以掌握容器的大小和容量。

求得容器的大小就要是用_finish 减去 _start 。

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

容量capacity() 使用_endofstorage 减去 _start 得出。

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

容器的插入和删除等操作

reserve

reserve用法：

1. 若是n大于capacity 容器的容量就扩大到 n
2. 若是n小于capacity 则容器容量不变。

void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t old_size = size();
		T* tmp = new T[n];
		/*memcpy(tmp, _start, size() * sizeof(T));*/
		for (int i = 0; i < size(); i++)
		{
			tmp[i] = _start[i];
		}
		delete[] _start;

		_start = tmp;
		_finish = tmp + old_size;
		_endofstorage = tmp + n;
	}
}

注意：

1. 需要注意的是要保存原有容器的大小，因为当原来的_start被释放后size不再与原来的相符合，这可能会导致_finish的变成随机值。
2. 当T是string时拷贝容器中的数据时不能使用memcpy进行拷贝，原因是会导致string进行浅拷贝。memcpy是按字节一个一个拷贝到tmp之中，等到调用结束后_start 被释放。而_start指向的原来的string中的字符串空间也会被释放。tmp中指向字符串的指针变成了野指针。string使用memcpy将数据拷贝了，但是指向的空间没有被拷贝。

我们在这里可以使用for循环将_start 中的值一个一个赋给tmp，而循环中使用赋值运算符重载。使得任意的类型（包括string）都能够使用深拷贝赋值。

push_back

尾插没有什么特别的，依旧是先判断容器是否已满。然后将数据尾插 ， _finish+1既可。

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

在insert实现后可以复用insert函数。

void push_back(const T& val = T())
{
	insert(end(), val);
}

empty

empty函数可以直接通过_start 和 _finish 来判断是否为空。

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

pop_back

尾删pop_back首先判断是否为空，在_finish - 1。

void pop_back()
{
	assert(!empty());
	_finish--;
}

insert

insert在pos位置插入数据，首先要判断容器是否已满，然后将数据后移，pos位置空出在pos位置插入数据。
需要注意的是在扩容的时候，要保存pos与_start之间的距离，更新pos。因为在扩容完成之后pos还指向原来的空间。

void insert(iterator pos, const T& val = T())
{
	if (_finish == _endofstorage)//判断容器是否已满
	{
		size_t len = pos - _start;//保存pos与_start之间的距离
		reserve(capacity() == 0 ? 4 : 2 * capacity());

		pos = _start + len;
	}
	iterator it = _finish - 1;
	while (it >= pos)
	{
		*(it + 1) = *it;
		it--;
	}
	*pos = val;
	_finish++;
}

erase

erase函数是删除pos位置的数据。我们首先要断言pos防止pos大于_finish或者小于_start，然后就让pos后面的数据覆盖，前一个覆盖后一个直到等于_finish为止，_finish-1。

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

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

	_finish--;
}

resize

resize函数用法：

1. 当n小于容器大小size时，将size缩小为n。
2. 当n大于容器大小size时，将size扩大到n，并且让扩大的数据都为val，若是val没有给出，则默认为容器存储的类型的默认构造的值。

void resize(size_t n, const T& val = T())
{
	if (n > capacity())
	{
		reserve(n);

		while (_finish < _start + n)
		{
			*_finish = val;
			_finish++;
		}
	}
	else
	{
		_finish = _start + n;
	}
}

swap

swap函数用于交换两个容器，我们可直接调用std中的swap交换各个成员变量。

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