namespace nzb
{
	//模擬實現(xiàn)vector
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		//默認成員函數(shù)
		vector();                                           //構(gòu)造函數(shù)
		vector(size_t n, const T& val);                     //構(gòu)造函數(shù)
		template<class InputIterator>
		vector(InputIterator first, InputIterator last);    //構(gòu)造函數(shù)
		vector(const vector<T>& v);                         //拷貝構(gòu)造函數(shù)
		vector<T>& operator=(const vector<T>& v);           //賦值重載
		~vector();                                          //析構(gòu)函數(shù)

		//迭代器相關(guān)函數(shù)
		iterator begin();
		iterator end();
		const_iterator begin()const;
		const_iterator end()const;

		//容量相關(guān)函數(shù)
		size_t size()const;
		size_t capacity()const;
		void reserve(size_t n);
		void resize(size_t n, const T& val = T());
		bool empty()const;

		//修改容器相關(guān)函數(shù)
		void push_back(const T& x);
		void pop_back();
		void insert(iterator pos, const T& x);
		iterator erase(iterator pos);
		void swap(vector<T>& v);

		//訪問容器相關(guān)函數(shù)
		T& operator[](size_t i);
		const T& operator[](size_t i)const;

	private:
		iterator _start;        //指向容器的頭
		iterator _finish;       //指向有效數(shù)據(jù)的尾
		iterator _endofstorage; //指向容器的尾
	};
}

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

vector(size_t n, const T& val)
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
	reserve(n); //擴容
	for (size_t i = 0; i < n; i++) //尾插
	{
		push_back(val);
	}
}

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

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

		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			vector<T> tmp(v.begin(), v.end());
			swap(tmp);
		}

vector<T>& operator=(const vector<T>& v)
{
	if (this != &v)
	{
		delete[] _start;
		_start = _finish = _endofstorage = nullptr;

		reserve(v.capacity());
		for (const auto& e : v)
		{
			push_back(e);
		}
	}	
	return *this;
}

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

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

typedef T* iterator;
typedef const T* const_iterator;

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

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

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

void reserve(size_t n)
{
	if (n > capacity()) 
	{
		size_t sz = size(); // 記錄原容器中數(shù)據(jù)個數(shù)
		T* tmp = new T[n]; // 開辟一塊容量為n的空間
		if (_start) //判空
		{
			for (size_t i = 0; i < sz; i++) // 拷貝數(shù)據(jù)
			{
				tmp[i] = _start[i];
			}
			delete[] _start; // 釋放原容器中的數(shù)據(jù)
		}
		_start = tmp; // 調(diào)整指針
		_finish = _start + sz; 
		_endofstorage = _start + n; 
	}
}

void resize(size_t n, const T& val = T())
{
	if (n <= size())// 當n小于當前的size時
	{
		_finish = n + _start;// 將size縮小到n
	}
	else // 當n大于當前的size時
	{
		if (n > capacity())// 當n大于容量時，擴容
		{
			reserve(n);
		}

		while (_finish < _start + n)// 給size到容器結(jié)尾賦值
		{
			*_finish = val;
			_finish++;
		}
	}
}

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

void push_back(const T& x)
{
	if (_finish == _endofstorage)// 判斷是否需要擴容
	{
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
	}
	// 尾插數(shù)據(jù)
	*_finish = x;
	_finish++;
}

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

iterator insert(iterator pos, const T& x)
{
	assert(pos >= _start&&pos <= _finish);// 判斷傳入數(shù)據(jù)的合法性
	if (_finish == _endofstorage)// 擴容
	{
		size_t len = pos - _start;// 記錄pos的位置
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
		pos = _start + len;
	}
	iterator end = _finish - 1;
	while (end >= pos)// 挪動數(shù)據(jù)
	{
		*(end + 1) = *end;
		--end;
	}
	*pos = x;// 插入數(shù)據(jù)
	_finish++;
	return pos;
}

iterator erase(iterator pos)
{
	assert(pos >= _start&&pos < _finish);// 判斷傳入數(shù)據(jù)的合法性
	iterator it = pos + 1;// 利用迭代器記錄pos的后一位
	while (it != _finish)// 將pos后的數(shù)據(jù)往前挪動一位
	{
		*(it - 1) = *it;
		it++;
	}
	_finish--;

	return pos;
}

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

T& operator[](size_t i)// 可讀可寫
{
	assert(i < size());
	return _start[i];
}

const T& operator[](size_t i) const// 只能讀
{
	assert(i<size());
	return _start[i];
}