std::vector<int> v1;//v1是存盤int型別的資料
	std::vector<string> v2;//v2存盤的是string型別的資料
	std::vector<char> v3;//v3是存盤char型別的資料

	std::vector<int> v1;//無參的建構式
	std::vector<int> v2(10, 2);//構造并初始化10個2
	std::vector<int> v3(v2.begin(), v2.end());//利用v2的迭代器初始化v3
	vector<int> v4(v2);//拷貝構造

void test(vector<int> v)
{
	vector<int>::iterator it = v.begin();
	cout << "正向迭代器遍歷:";
	while (it != v.end())//正向迭代器遍歷
	{
		cout << *it << ' ';
		it++;
	}
	cout << endl;

	vector<int>::reverse_iterator rt = v.rbegin();
	cout << "反向迭代器遍歷:";
	while (rt != v.rend())//反向迭代器遍歷
	{
		cout << *rt << ' ';
		rt++;
	}	
	cout << endl;
}

	std::vector<int> v1;//無參的建構式
    v1.push_back(1);//尾插
	v1.push_back(2);//尾插
	v1.push_back(3);//尾插
	v1.push_back(4);//尾插
	v1.push_back(5);//尾插

	//查找3的位置，并將回傳的迭代器存盤在pos
	vector<int>::iterator pos = find(v1.begin(), v1.end(), 3);
	v1.insert(pos, 30);//在pos位置之前插入30
	reverse(v1.begin(), v1.end());//逆置vector
	//查找3的位置，并將回傳的迭代器存盤在it
	vector<int>::iterator it = find(v1.begin(), v1.end(), 4);
	v1.erase(it);//洗掉it位置的資料

	std::vector<int> v;
	cout << v.capacity() << endl;//輸出0
	cout << v.size() << endl;//輸出0
	v.reserve(10);//預留10個capacity的空間大小
	cout << v.capacity() << endl;//輸出10
	cout << v.size() << endl;//輸出0
	v.resize(20,10);//預留20個資料
	cout << v.capacity() << endl;// 輸出20
	cout << v.size() << endl;//輸出20

void test2()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(10);
	v.push_back(4);
    vector<int>::iterator pos = find(v.begin(), v.end(), 2);
	v.insert(pos,10);
	v.insert(pos, 20);
}

namespace sjp
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator; //vector的迭代器是可以修改的
		typedef const T* const_iterator;

        iterator begin()//回傳vector迭代區間的頭
		{
			return _first;
		}
		iterator end()//回傳vector的迭代區間的尾
		{
			return _end;
		}

		const_iterator begin()const
		{
			return _first;
		}

		const_iterator end()const
		{
			return _end;
		}

		size_t size()const//回傳vector的資料個數
		{
			return _end - _first;
		}

		size_t capacity()const//回傳vector的容量
		{
			return _end_of_storage - _first;
		}

        bool empty()const//判斷vector是否為空
		{
			return _first == _end;
		}

		const T& operator[](size_t i)const
		{
			return *(_first + i);
		}

		T& operator[](size_t i)
		{
			return *(_first + i);
		}

		void clear()//清空vector
		{
			_end = _first;
		}


		const T& back()const//回傳vector最后一個元素
		{
			return *(back - 1);
		}


		const T& front()const//回傳vector第一個元素
		{
			return *(front);
		}


	private:
		iterator _first;//表示目前使用空間的頭
		iterator _end;//表示目前使用空間的尾
		iterator _end_of_storage;//表示目前可用空間的尾
	};

     void reserve(size_t n)
		{
			size_t sz = size();//先保存原本的size
			if (capacity() < n)
			{
				T* tmp = new T[n];//重新開一塊空間
				if (_first)//如果_first不為空指標
				{
					for (int i = 0; i < size(); i++)//將原空間的值拷貝給新空間
					{
						tmp[i] = _first[i];
					}
					delete[] _first;//釋放舊空間
				}
				//讓迭代器指向新空間
				_first = tmp;
				_end = _first + sz;
				_end_of_storage = _first + n;
			}
		}

		void resize(size_t n,T val=T())
		{
			if (n > size())
			{
				if (n > capacity())//如果預留資料個數大于容量則需要增容
				{
					reserve(n);
				}
				size_t sz = n - size();//將資料補齊到n個
				for (int i = 0; i < sz; i++)
				{
					push_back(val);
				}
			}
		}

 		void insert(iterator pos,const T& x)
		{
			assert(pos >= _first && pos <= _end);
			if (_end == _end_of_storage)//判斷容量是否滿了
			{
				size_t lenth = pos - _first;//如果換新空間，需要保留pos在vector的位置
				int newcapacity = capacity() == 0 ? 5 : capacity() * 2;
				reserve(newcapacity);//預留新空間
				pos =_first+lenth;//跟新pos
			}
			//將x插入到pos位置的前面
			iterator cur = end();
			while (cur != pos)
			{
				*(cur) = *(cur-1);
				cur--;
			}
			*pos = x;	
			_end += 1;//資料個數再加一
		}

		void push_back(const T& x)//尾插，直接在最后一個位置插入資料即可
		{
			insert(_end, x);
			//if (_end == _end_of_storage)
			//{
			//	int newcapacity = capacity() == 0 ? 5 : capacity() * 2;
			//	reserve(newcapacity);
			//}
			//*_end = x;
			//++_end;
		}

		iterator erase(iterator pos)
		{
			assert(pos < _end);	
			iterator cur = pos;//將pos位置后的所有資料向前挪一步
			while (cur != _end - 1)
			{
				*cur = *(cur + 1);	
				cur++;
			}
			_end--;//資料個數再減一
			return pos;
		}

		void pop_back()
		{
			--_end;
		}

		vector(size_t n, T val)//構造n個val值的vector
		{
			reserve(n);//先預留n個資料的空間
			for (int i = 0; i < n; i++)//再將val存滿這塊空間
			{
				push_back(val);
			}
		}

		vector()//無參的拷貝構造
		 :_first(nullptr),_end(nullptr),_end_of_storage(nullptr)
		{

		}

        vector(iterator first, iterator end)//利用迭代器區間構造vector
			:_first(nullptr), _end(nullptr), _end_of_storage(nullptr)
		{
			while (first != end)
			{
				push_back(*first);
				first++;
			}
		}

        //v2(v1);
		vector(const vector<T>& v)//拷貝建構式
			:_first(nullptr),_end(nullptr),_end_of_storage(nullptr)
		{
			reserve(v.capacity());//預留v1相同的空間
			for ( auto e: v)//然后將v1中的資料一個一個的推進v2
			{
				push_back(e);
			}
		}

        //v2=v1
		vector<T>& operator=(const vector<T>& v)//賦值建構式
		{
			vector<T> tmp(v);
			swap(_first, tmp._first);//不能用用=賦值進行賦值，tmp出函式作業域或被析構掉，
			swap(_end, tmp._end);
			swap(_end_of_storage, tmp._end_of_storage);
			return *this;
		}