vector的简单模拟实现

#pragma once
#include<iostream>
#include<assert.h>


namespace QR
{
		template<class T>
		class vector
		{
		public:
			typedef T* iterator;
			typedef const T* const_iterator;

			vector()
				:_start(nullptr)
				,_finish(nullptr)
				,_endofstorage(nullptr)
			{}
			//v2(v1)
			//传统写法
			/*vector(const vector<T>& v)
			{
				_start = new T[v.capacity()];
				_finish = _start + v.size();
				_endofstorage = _start + v.capacity();

				memcpy(_start, v._start, v.size() * sizeof(T));
			}*/
			
			//一个类模板的成员函数，也可以是一个函数模板
			template<class InputIterator>
			vector(InputIterator first, InputIterator last)
				:_start(nullptr)
				,_finish(nullptr)
				,_endofstorage(nullptr)
			{
				while (first != last)
				{
					push_back(*first);
					first++;
				}
			}

			void swap(vector<T>& v)
			{
				std::swap(_start, v._start);
				std::swap(_finish, v._finish);
				std::swap(_endofstorage, v._endofstorage);
			}
			//现代写法
			vector(const vector<T>& v)
				:_start(nullptr)
				, _finish(nullptr)
				, _endofstorage(nullptr)
			{
				vector<int>tmp(v.begin(), v.end());
				swap(tmp);
			}

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

			iterator begin()
			{
				return _start;
			}

			iterator end()
			{
				return _finish;
			}

			const_iterator begin() const
			{
				return _start;
			}

			const_iterator end() const
			{
				return _finish;
			}

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

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

			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();
					T* tmp = new T[n];
					if (_start)
					{
						memcpy(tmp, _start, sizeof(T) * size());
						delete[]_start;
					}
					_start = tmp;
					//这里的size()得提前算好，不然就会出现问题。因为_start被更新了
					//_finish = _start + size();
					_finish = _start + sz;
					_endofstorage = _start + n;
				}
			}

			void resize(size_t n, const T& val = T())
			{
				if (n < size())
				{
					_finish = _start + n;
				}
				else
				{
					if (n > capacity())
					{
						reserve(n);
					}
					while (_finish != _start + n)
					{
						*_finish = val;
						++_finish;
					}
				}
				
			}
			void push_back(const T& x)
			{
				if (_finish == _endofstorage)
				{
					//扩容
					reserve(capacity() == 0 ? 4 : capacity() * 2);
				}
				*_finish = x;
				++_finish;
			}

			void pop_back()
			{
				assert(_start < _finish);
				_finish--;
			}

			iterator insert(iterator pos, const T& x)
			{
				assert(pos >= _start);
				assert(pos <= _finish);
				//空间满了就扩容
				//扩容会导致pos失效，在扩容前需要更新pos
				if (_finish == _endofstorage)
				{
					size_t len = pos - _start;
					reserve(capacity() == 0 ? 4 : capacity() * 2);
					pos = _start + len;
				}
				iterator end = _finish - 1;
				while (end >= pos)
				{
					*(end + 1) = *end;
					end--;
				}
				*pos = x;
				++_finish;
				return pos;
			}

			iterator erase(iterator pos)
			{
				assert(pos >= _start);
				assert(pos <= _finish);
				iterator begin = pos + 1;
				while (begin < _finish)
				{
					*(begin - 1) = *begin;
					++begin;
				}
				--_finish;
				return pos;
			}


		private:
			iterator _start;
			iterator _finish;
			iterator _endofstorage;
		};
		void vector_test1()
		{
			vector<int> v;
			v.push_back(1);
			v.push_back(2);
			v.push_back(3);
			v.push_back(4);
			v.push_back(5);
			v.push_back(6);
			for (size_t i = 0; i < v.size(); i++)
			{
				std::cout << v[i] << ' ';
			}
			std::cout << std::endl;

			vector<int>::iterator it = v.begin();
			while (it != v.end())
			{
				std::cout << *it << ' ';
				it++;
			}
			std::cout << std :: endl;

			for (auto e : v)
			{
				std::cout << e << ' ';
			}
			std::cout << std::endl;

		}

		void vector_test2()
		{
			vector<int> v1;
			v1.push_back(1);
			v1.push_back(2);
			v1.push_back(3);
			v1.push_back(4);
			vector<int> v2(v1);
			for (auto e : v2)
			{
				std::cout << e << " ";
			}
			std::cout << std::endl;

			vector<int> v3 = v1;
			for (auto e : v3)
			{
				std::cout << e << " ";
			}
			std::cout << std::endl;
		}

		void vector_test3()
		{
			vector<int> v1;
			v1.push_back(1);
			v1.push_back(2);
			v1.push_back(3);
			v1.push_back(3);
			v1.push_back(3);
			

			vector<int>::iterator it =std::find(v1.begin(), v1.end(), 2);

			if (it != v1.end())
			{
				//如果insert中发生了扩容，那么会导致it指向的空间被释放
				//it本质就是一个野指针，这种问题就称为迭代器失效
				v1.insert(it, 20);
			}
			for (auto e : v1)
			{
				std::cout << e << " ";
			}
			std::cout << std::endl;
		}

		void vector_test5()
		{
			// 三种场景去测试
			// 1 2 3 4 5 -> 正常
			// 1 2 3 4   -> 崩溃
			// 1 2 4 5   -> 没删除完
			vector<int> v1;
			v1.push_back(1);
			v1.push_back(2);
			v1.push_back(4);
			v1.push_back(5);
			//v1.push_back(5);
			/*vector<int>::iterator it = find(v1.begin(), v1.end(), 2);
			if (it != v1.end())
			{
				v1.erase(it);
			}*/

			// 要求删除v1所有的偶数
			/*vector<int>::iterator it = v1.begin();
			while (it != v1.end())
			{
				if (*it % 2 == 0)
				{
					v1.erase(it);
				}

				++it;
			}*/

			vector<int>::iterator it = v1.begin();
			while (it != v1.end())
			{
				if (*it % 2 == 0)
				{
					it = v1.erase(it);
				}
				else
				{
					++it;
				}
			}

			for (auto e : v1)
			{
				std::cout << e << " ";
			}
			std::cout << std::endl;
		}
}