vector的模拟实现

cpp	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
	private:
		iterator start;
		iterator finish;//这里的finish指向的是最后一个数的下一个位置
		iterator end_of_storage;
	};

cpp		size_t size()cosnt
		{
			return finish - start;
		}
		size_t capacity()const 
		{
			return end_of_storage - start;
		}

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

cpp		T& front()
		{
			return *start;
		}
		T& back()
		{
			return *(finish - 1);
		}

cpp		T& operator[](size_t pos)
		{
			assert(pos < size());
			return *(start + pos);
		}
                const T& operator[](size_t pos)const
		{
			assert(pos < size());
			return *(start + pos);
		}

cpp		bool empty()
		{
			return start == finish;
		}

cpp		vector()
			:start(nullptr)
			, finish(nullptr)
			, end_of_storage(nullptr)
		{}

cpp		vector(size_t n, const T& val = T())
			:start(nullptr),finish(nullptr),end_of_storage(nullptr)
			//写这句话的目的就是因为开始的时候指针都没有初始化，都是野指针，当开辟空间的时候会出现错误。
		{
			reserve(n);
			for (size_t i = 0; i < n; ++i)
			{
				start[i] = val;
			}
			finish = start + n;
		}

cpp		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
			:start(nullptr),finish(nullptr),end_of_storage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}

cpp		vector(const vector<T>& v)
		{
			start = new T[v.size()];
			for (size_t i = 0; i < v.size(); ++i)
			{
				start[i] = v.start[i];
			}
			finish = start + v.size();
			end_of_storage = finish;
		}

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

cppvoid reserve(size_t n)
{
if (n > capacity())
{
    size_t sz = size();
    T* tmp = new T[n];
    if (start)
    {
        for (size_t i = 0; i < sz; ++i)
        {
            tmp[i] = start[i];//要注意这里，当这里是自定义类型的时候，这里就是赋值（赋值运算符的重载，要自己实现一下）
        }
        delete[] start;
    }
    start = tmp;
    finish = start + sz;//这里需要改变数据结尾指针的指向，因为空间重新开辟了。
    end_of_storage = start + n;//当然，空间的指针指向也需要改变
    }
}

cpp	void resize(size_t n, const T& val = T())
	{
		if (n < size())
		{
			finish = start + n;
		}
		else if (n > size())
		{
			iterator temp = new T[n];
			for (size_t i = 0; i < n; ++i)
			{
				if (i < size())
					temp[i] = start[i];
				else
					temp[i] = val;
			}
			delete[] start;
			start = temp;
			finish = start + n;
			end_of_storage = finish;
		}
	}

cpp		void push_back(const T& x)
		{
			if (size() == capacity())
			{
				//扩容
				size_t len = size() == 0 ? 4 : size() * 2;
				reserve(len);
			}
			*finish = x;
			finish++;
		}

cpp		void pop_back()
		{
			assert(size());
			--finish;
		}

cpp	iterator erase(iterator pos)
	{
		assert(pos < finish);
		assert(pos >= start);
		iterator cur = pos;
		while (cur != finish)
		{
			*cur = *(cur + 1);
			cur++;
		}
		finish--;
		return pos;
	}

cpp	iterator insert(iterator pos, const T& x)
	{
		assert(pos <= finish);
		assert(pos >= start);
		size_t p = pos - start;
		if (finish == end_of_storage)
		{
			reserve(capacity() + 1);
		}
		for (size_t i = size()-1; i>p; --i)
		{
			start[i] = start[i - 1];
		}
		start[p] = x;
		return start + p;
	}

cpp	vector<T>& operator=(const vector<T>& v)
	{
		if (start != v.start)
		{
			iterator temp = new T[v.size()];
			for (size_t i = 0; i < v.size(); ++i)
			{
				temp[i] = v.start[i];
			}
			delete[] start;
			start = temp;
			finish = start + v.size();
			end_of_storage = finish;
		}
		return *this;
	}