vector的模拟实现

vector和数组看起来的却别在于一个是静态的，另外一个是动态的。而vector扩容时候，现要数据搬移到新的空间然后在释放掉以前的空间。
我们模拟实现我们感觉最需要注意的还是扩容问题什么时候扩容什么时候不用扩容。
已经一个检查vector扩容的接口函数
也不知怎么说vector常用的接口，感觉主要分三类，第一类创建vector类，第二类修改vector元素类，第三类遍历元素类。

-感觉vector涉及到元素修改时候我们都需要注意的一个因素就是迭代器失效了，以及在细分三种情况

• 第一种修改以后空间给reserve申请的空间更大，不能装满触发了扩容，我们需要经行扩容然后搬移数据，在销毁以前的空间。
• 第二种我们虽然修改了元素，但是我们申请的元素空间没有用完，但是比上一次修改元素操作所占用的元素空间大，我们只需要在原有空间上插入数据。并不需要经行元素的搬移。
• 第三种我们这次操作比以前的操作数据的大小还要小的情况下，我们只需要改变元素的大小就可以了。第三种虽然简单一些，但是我感觉还是最容易忘记的，有时候减少元素我们会忘记考虑判空，在resize当中也有这种情景，但是我们却很容易葫芦这一种情况。
  好了，看代码吧

#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
template<class T>
class Vector
{
public:
	typedef T* Iterator;

public:
	Vector()
		: _start(0)
		, _finish(0)
		, _endOfStorage(0)
	{}

	
	Vector(size_t size, const T& data = T())
		: _start(new T[size])
		, _finish(_start + size)
		, _endOfStorage(_start + size)
	{
		
		for (size_t i = 0; i < size; ++i)
			_start[i] = data;

		
	}

	Vector(const T* first, const T* last)
	{
		size_t size = last - first;
		_start = new T[size];
		// 1. 
		for (size_t i = 0; i < size; ++i)
			_start[i] = first[i];

		

		_finish = _start + size;
		_endOfStorage = _finish;
	}

	Vector(const Vector<T>& v);
	Vector<T>& operator=(const Vector<T>& v);
	~Vector()
	{
		if (_start)
		{
			delete[] _start;
			_start = 0;
			_finish = 0;
			_endOfStorage = 0;
		}
	}


	
	Iterator Begin()
	{
		return _start;
	}

	Iterator End()
	{
		return _finish;
	}

	void PushBack(const T& data)
	{
		_CheckCapacity();
		*_finish = data;
		++_finish;
	}

	
	void PopBack()
	{
		if (_start == _finish)
			return;

		--_finish;
	}
	
	void Clear()
	{
		_finish = _start;
	}

	void Swap(Vector<T>& v)
	{
		swap(_start, v._start);
		swap(_finish, v._finish);
		swap(_endOfStorage, v._endOfStorage);
	}

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

	size_t Capacity()const
	{
		return _endOfStorage - _start;
	}

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

	
	void ReSize(size_t newSize, const T& data = T())
	{
		size_t oldSize = Size();
		if (newSize <= oldSize)
			_finish = _start + newSize;
		else
		{
			size_t capacity = Capacity();
			if (newSize < capacity)
			{
				while (newSize != oldSize)
				{
					*_finish = data;
					++_finish;
					--newSize;
				}
			}
			else
			{
				
				T* pTmp = new T[newSize];
				if (_start)
				{
					
					for (size_t i = 0; i < oldSize; ++i)
						pTmp[i] = _start[i];

					for (size_t i = oldSize; i < newSize; ++i)
						pTmp[i] = data;

					
					delete[] _start;
				}


				_start = pTmp;
				_finish = _start + newSize;
				_endOfStorage = _finish;
			}
		}
	}

	void Reserve(size_t n)
	{
		if (n > Capacity())
		{
			
			size_t size = Size();
			T* pTmp = new T[n];
			if (_start)
			{
				
				for (size_t i = 0; i < size; ++i)
					pTmp[i] = _start[i];

				
				delete[] _start;
			}


			_start = pTmp;
			_finish = _start + size;
			_endOfStorage = _start + n;
		}
	}


	
	T& operator[](size_t index)
	{
		assert(index < Size());
		return _start[index];
	}

	const T& operator[](size_t)const
	{
		assert(index < Size());
		return _start[index];
	}

	T& Front()
	{
		return *_start;
	}

	const T& Front()const
	{
		return *_start;
	}

	T& Back()
	{
		return *(_finish - 1);
	}

	const T& Back()const
	{
		return *(_finish - 1);
	}

private:
	void _CheckCapacity()
	{
		if (_finish == _endOfStorage)
		{
			size_t size = Size();
			size_t newSize = size * 2 + 3;
			T* pTmp = new T[newSize];

			if (_start)
			{
				// 如何区分T是否为内置类型？
				if (false)
				{
					memcpy(pTmp, _start, size * sizeof(T));
				}
				else
				{
					for (size_t i = 0; i < size; ++i)
						pTmp[i] = _start[i];
				}

				delete[] _start;
			}

			_start = pTmp;
			_finish = _start + size;
			_endOfStorage = _start + newSize;
		}
	}

private:
	T* _start;
	T* _finish;
	T* _endOfStorage;
};
void TestVectorint()
{
	Vector<int> v1;
	v1.PushBack(1);
	v1.PushBack(2);
	v1.PushBack(3);
	v1.PushBack(4);

	cout << v1.Size() << endl;
	cout << v1.Capacity() << endl;
	cout << v1.Front() << endl;
	cout << v1.Back() << endl;
	for (size_t i = 0; i < v1.Size(); ++i)
		cout << v1[i] << " ";
	cout << endl;

	v1.PopBack();
	v1.PopBack();
	cout << v1.Size() << endl;
	cout << v1.Capacity() << endl;
	cout << v1.Front() << endl;
	cout << v1.Back() << endl;
	for (size_t i = 0; i < v1.Size(); ++i)
		cout << v1[i] << " ";
	cout << endl;

	v1.ReSize(20, 9);
	Vector<int>::Iterator it = v1.Begin();
	while (it != v1.End())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}
int main()
{
	TestVectorint();
	return 0;
}

我们通过模拟的迭代器遍历一遍。

好了，具体就这样样了，主要是接口比较多一点，但是基本思路也就上面这一点的。