【C++】vector类的模拟实现

vector类的模拟实现

vector的认识：

vector是一个大小可以改变的序列式容器，也称为数组。也就是说vector是一段连续的空间来存储数据。
同样vector也有一系列的接口，我们要熟练使用vector的接口，首先要理解vector接口的底层实现，才能灵活运用。

vector主要也就是实现存储类型T的增删改查，同样，为了方便实现这些操作，vector底层运用了三个迭代器：_start指向数组的首部，_end指向数组中数据的下一个位置，_end_of_storage指向数组中最大容量的位置。
下面是其实现：

模拟实现

#include <iostream>
#include <cassert>
using namespace std;

template <class T>
class Vector
{
	
public:
	typedef T* iterator;
	Vector()
		:_start(nullptr)
		, _finish(nullptr)
		, _end_of_storage(nullptr)
	{}
	~Vector()
	{
		if (_start)
		{
			delete[]_start;
			_start = _finish = _end_of_storage = nullptr;
		}
	}
	Vector(const Vector<T>& v) 
	{
		_start = new T[v.size()];
		memcpy(_start, v._start,sizeof(T)*v.size());
		_finish = _start + v.size();
		_end_of_storage = _start + v.size();

		
	}
	void Swap(Vector<T>& v)
	{
		swap(_start, v._start);
		swap(_finish, v._finish);
		swap(_end_of_storage, v._end_of_storage);
	}
	Vector<T>& operator=(Vector<T> v)
	{
		Swap(v);
		return *this;
	}
	void resize(size_t n, const T& val = T())
	{
		if (n < size())
		{
			_finish = _start + n;
		}

		if (n > capacity())
		{
			reverse(n);
		}
		while (_finish != _start + n)
		{
			*_finish = val;
			++_finish;
		}
	}
	void reverse(size_t n)
	{
		if (n > capacity())
		{
			T * tmp = new T[n];
			
			int sz = size();
			//拷贝数据
			memcpy(tmp,_start,sizeof(T)*size());
			delete[] _start;
			_start = tmp;
			_finish = _start + sz;
			_end_of_storage = _start + n;
		}
	}

	void push_back(const T& val)
	{
		if (_finish == _end_of_storage)
		{
			size_t newcapacity = capacity() == 0 ? 2 : 2 * capacity();
			reverse(newcapacity);
		}
		*_finish = val;
		++_finish;
	}

	void pop_back()
	{
		assert(_finish > _start);
		--finish;
	}
	void insert(iterator pos, const T& x)
	{
		if (_finish == _end_of_storage)
		{
			//这里是先选出pos在原来空间上的绝对位置是多少
			size_t n = pos - _start;
			size_t newcapacity = capacity() == 0 ? 2 : 2 * capacity();
			reverse(newcapacity);
			//在新空间上的绝对位置
			pos = _start + n;
		}
		iterator end = _finish - 1;
		while (end >= pos)
		{
			*(end + 1) = *end;
			--end;
		}
		*pos = x;
		++_finish;
	}
	void erase(iterator pos)
	{
		assert(pos >= _start &&  pos < _finish);
		iterator begin = pos + 1;
		while (begin < _finish)
		{
			*(begin - 1) = *begin;
			begin++;
		}
		--_finish;
	}
	size_t size() const
	{
		return _finish - _start;
	}

	size_t capacity() const
	{
		return _end_of_storage - _start;
	}
	T& operator[](size_t pos) const
	{
		return _start[pos];
	}

	const T& operator[](size_t pos) const 
	{
		return _start[pos];
	}
	iterator begin()
	{
		return _start;
	}
	iterator end()
	{
		return _finish;
	}

private:
	iterator _start;
	iterator _finish;
	iterator _end_of_storage;
};


void test1()
{
	Vector<int> v;
	v.push_back(1);
	v.push_back(2);

	v.push_back(3);
	v.push_back(4);
	v.insert(v.begin(), 10);
	auto it = v.begin();
	v.erase(it);
	v.erase(it);
	v.erase(it);
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}

int main()
{

	Vector<int> v1;
	v1.push_back(1);
	v1.push_back(1);

	v1.push_back(1);
	v1.push_back(1);

	Vector<int> v(v1);
	for (auto e : v)
	{
		
		cout << e << " ";

	}

	system("pause");
}