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;
		}