typedef T* iterator;
typedef const T* const_iterator;

iterator begin()
{
	return start;
}
iterator end()
{
	return finish;
}

const iterator cbegin()const
{
	return start;
}
const iterator cend()const
{
	return finish;
}

vector()
	:start(nullptr)
	, finish(nullptr)
	, endOfStorage(nullptr)
{}

vector(size_t n, const T& value = T())
	:start(new T[n])
	, finish(start)
	, endOfStorage(start + n)
{
	for (int i = 0; i < n; i++)
	{
		*finish++ = value;
	}
}

vector(int n, const T& value = T())
	:start(new T[n])
	, finish(start)
	, endOfStorage(start + n)
{
	for (int i = 0; i < n; i++)
	{
		*finish++ = value;
	}
}

//寫成函數(shù)模板，可以接受任意類型的迭代器
template<typename Iterator>
vector(Iterator first, Iterator last)
{
	size_t n = ZH::distance(first, last);//獲取長度
	start = new T[n];
	finish = start;
	endOfStorage = start + n;
	while (first != last){
		*finish = *first;
		first++;
		finish++;//完成賦值的同時也移動了finish的位置
	}
}

template<typename Iterator>
//此處的Iterator是模板參數(shù)，表示可以傳任意類型的迭代器
size_t distance(Iterator first, Iterator last)
{
	//獲取元素個數(shù)，暫時只考慮底層空間連續(xù)的情況
	int count = 0;
	while (first != last)
	{
		first++;
		count++;
	}
	return count;
}

//此處拷貝構(gòu)造函數(shù)的形參是const類型
vector(const vector<T>& v)
	:start(nullptr)
	, finish(nullptr)
	, endOfStorage(nullptr)
{
	//▲用const類型的迭代器訪問const變量
	vector<T> temp(v.cbegin(), v.cend());
	this->swap(temp);
}

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

~vector()
{
	delete[]start;
	start = nullptr;
	finish = nullptr;
	endOfStorage = nullptr;
}

size_t size()
{
	return finish - start;
}
size_t capacity()
{
	return endOfStorage - start;
}

size_t empty()
{
	return finish == start;
}

void resize(size_t newsize, const T& value = T())
{
	size_t oldsize = size();
	if (newsize > oldsize){
		if (newsize > capacity()){
			reserve(newsize);
		}
		for (size_t i = oldsize; i < newsize; i++)
		{
			start[i] = value;
		}
	}
	finish = start + newsize;//不用考慮增加或減小
}

void reserve(size_t newcapacity)
{
	size_t oldcapacity = capacity();
	if (newcapacity > oldcapacity)
	{
		size_t n = size();//保存size()的值
		T* temp = new T[newcapacity];
		//start不為空時才進(jìn)行拷貝舊空間元素和釋放的操作
		if (start)
		{
			//memcpy淺拷貝，當(dāng)vector中存放的對象內(nèi)部設(shè)計資源管理
			// 會有內(nèi)存泄漏和野指針問題
			//memcpy(temp, start, sizeof(T) * n);

			for (size_t i = 0; i < n; i++)
			{
				temp[i] = start[i];//調(diào)用賦值運算符重載
			}
			delete[] start;
		}
		start = temp;
		//▲此處不能用satart+size(),因為size方法中有finish-start,而start值已經(jīng)改變
		finish = start + n;
		endOfStorage = start + newcapacity;
	}
}

T& operator[](size_t index)
{
	assert(index < size());
	return start[index];
}

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

T& front()
{
	return start[0];
}
const T& front()const
{
	return start[0];
}

T& back()
{
	return *(finish - 1);
}
const T& back()const
{
	return *(finish - 1);
}

void push_back(const T& value)
{
	if (finish == endOfStorage)
	{
		//因為原來的capacity可能為0,所以要+3
		reserve(capacity() * 2 + 3);
	}
	*finish++ = value;
}

void pop_back()
{
	if (empty())
	{
		return;
	}
	finish--;
}

//第二個參數(shù)用const修飾，常量引用
//不用const修飾則為非常量引用
iterator insert(iterator pos, const T& value)
{
	int index = pos - start;
	assert(pos >= start && pos < finish);
	//判斷空間是否足夠
	if (finish == endOfStorage)
	{
		reserve(capacity() * 2);
	}
	pos = start + index;
	for (auto it = finish; it > pos; it--)
	{
		*it = *(it - 1);
	}
	*pos = value;
	finish++;
	return pos;
}

iterator erase(iterator pos)
{
	assert(pos >= start && pos < finish);

	auto it = pos;
	while (it < finish - 1)
	{
		*it = *(it + 1);
		it++;
	}
	finish--;
	return pos;
}

void clear()
{
	finish = start;
}

void swap(vector<T>& v)
{
	std::swap(start, v.start);
	std::swap(finish, v.finish);
	std::swap(endOfStorage, v.endOfStorage);
}

private:
	iterator start;
	iterator finish;
	iterator endOfStorage;