迭代器实现Vector

      迭代器是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。迭代器修改了常规指针的接口，所谓迭代器是一种概念上的抽象：那些行为上像迭代器的东西都可以叫做迭代器。然而迭代器有很多不同的能力，它可以把抽象容器和通用算法有机的统一起来。

迭代器提供一些基本操作符：*、++、==、!=、=。这些操作和C/C++“操作array元素”时的指针接口一致。不同之处在于，迭代器是个所谓的智能指针，具有遍历复杂数据结构的能力。其下层运行机制取决于其所遍历的数据结构。因此，每一种容器型别都必须提供自己的迭代器。事实上每一种容器都将其迭代器以嵌套的方式定义于内部。因此各种迭代器的接口相同，型号却不同。这直接导出了泛型程序设计的概念：所有操作行为都使用相同接口，虽然它们的型别不同。

下面使用迭代器实现Vector的代码，对于智能指针等新知识我们之后会不断学习。

#pragma once
#include<assert.h>
#include<iostream>
using namespace std;

template<class T>
struct Vector
{
public:
	typedef T* Iterator;
public:
	Vector()
		: _start(0)
		, _finish(0)
		, _endOfStorage(0)
	{}

	Vector(const T* array, size_t size)
		:_start(new T[size])
		, _finish(_start)
		, _endOfStorage(_start+size)
	{
		for (size_t i = 0; i < size; i++)
		{
			*finish++ = array[i];
		}
	}

	Vector(const Vector& v)
	{
		size_t size = v.Size();
		_start = new T[size];
		for (size_t i = 0; i < size; i++)
		{
			_start[i] = v._start[i];
		}
		_finish = _start + size;
		_endOfStorage = _finish;
	}

	Vector& operator=(const Vector& s)
	{
		size_t size = s.Size();
		if (this != &s)
		{
			T *tmp = new T[size];
			for (size_t i = 0; i < size; i++)
			{
				tmp[i] = s._start[i];
			}
			delete[] _start;
			_start = tmp;
			_finish = _start + size;
			_endOfStorage = _start + size;
		}
		return *this;
	}
	~Vector()
	{
		if (_start)
		{
			delete[] _start;
			_start = 0;
			_finish = 0;
			_endOfStorage = 0;
		}
	}

//////////////Iterator///////////////////////////////// 
	Iterator Begin()
	{
		return _start;
	}
	Iterator End()
	{
		return _finish;
	}
	void PushBack(const T& data)
	{
		_CheckCapacity();
		*_finish++ = data;
	}

	void PopBack()
	{
		_finish--;
	}

	void Insert(size_t pos, const T& data)
	{
		assert(pos <= Size());
		_CheckCapacity();
		for (size_t i = Size(); i >= pos; i--)
		{
			_start[i] = _start[i - 1];
		}
		_start[pos - 1] = data;
		_finish++;
	}

	void Erase(size_t pos)
	{
		assert(pos < Size());
		for (size_t i = pos - 1; i < Size(); i++)
		{
			_start[i] = _start[i + 1];
		}
		_finish--;
	}

	//////////////////capacity//////////////////////////// 
	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 if ((newSize > oldSize) && (newSize <= Capacity()))
		{
			for (size_t i = oldSize; i < newSize; i++)
			{
				_start[i] = data;
			}
			_finish = _start + newSize;
		}
		else
		{
			T *tmp = new T[newSize];
			for (size_t i = 0; i < oldSize; i++)
			{
				tmp[i] = _start[i];
			}
			for (size_t j = oldSize; j < newSize; j++)
			{
				tmp[j] = data;
			}
			delete[] _start;
			_start = tmp;
			_finish = _start + newSize;
			_endOfStorage = _finish;
		}

	}

	//////////////Acess/////////////////////////// 
	T& operator[](size_t index)
	{
		return _start[index];
	}

	const T& operator[](size_t index)const
	{
		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);
	}

	void Clear()
	{
		_start = _finish;
	}

private:
	void _CheckCapacity()
	{
		size_t size = Size();
		size_t capacity = Capacity();
		size_t newCapacity = capacity * 2 + 3;
		if (size >= capacity)
		{
			//申请新空间
			T *tmp = new T[newCapacity];
			//拷贝元素
			if (_start)
			{
				for (size_t i = 0; i < size; i++)
				{
					tmp[i] = _start[i];
				}
			}
			if (_start)
				delete[] _start;
			_start = tmp;
			_finish = _start + size;
			_endOfStorage = _start + newCapacity;
		}
	}
	template<class T>
	friend ostream& operator<<(ostream& _cout, const Vector<T>& v)
	{
		for (size_t i = 0; i < v.Size(); ++i)
			cout << v[i] << " ";
		cout << endl;
		return _cout;
	}
private:
	T* _start;
	T* _finish;
	T* _endOfStorage;
};

void test1()
{
	Vector<int> v1;
	Vector<int> v2;

	v1.PushBack(1);
	v1.PushBack(2);
	v1.PushBack(3);
	v1.PushBack(4);
	v1.PushBack(5);               //v1为1，2，3，4，5

	Vector<int> v3(v1);
	cout << v3;                   //v3为1，2，3，4，5
	v2 = v1;                      //v2为1，2，3，4，5
	v2.PopBack();                 //v2为1，2，3，4

	cout << v1;
	cout << v2;

	v1.Insert(5, 6);              //v1为1，2，3，4，6，5
	cout << v1;

	v1.Erase(1);                  //v1为2，3，4，6，5
	cout << v1;
}
void test2()
{
	Vector<int> v1;
	v1.PushBack(1);
	v1.PushBack(2);
	v1.PushBack(3);
	cout << v1;                                  //1,2,3
	cout << v1.Size() << endl;                   //3 3
	cout << v1.Capacity() << endl;

	v1.Resize(5, 0);
	cout << v1;                                  //1,2,3,0,0
	cout << v1.Size() << endl;                   //5
	cout << v1.Capacity() << endl;               //5

	cout << v1[2] << endl;                       //3
	cout << v1.Front() << endl;                  //1
	cout << v1.Back() << endl;                   //0

	v1.Clear();
	cout << v1.Empty() << endl;                  //1
	cout << v1.Size() << endl;                   //0
	cout << v1.Capacity() << endl;               //5
}

int main()
{
	test1();

	system("pause");
	return 0;
}