c++vector基本實現

#include<iostream>
#include<algorithm>
#include<assert.h>
#include<string>
using namespace std;

namespace bit{
	template<class T>
	class Vector
	{
	public:
		//Vector的迭代器是一個原生的指針
		typedef T* Iterator;
		typedef const T* ConstIterator;
		Iterator Begin(){ return _start; }//第一個元素的位置
		Iterator End(){ return _finish; }//最後一個元素的位置
		ConstIterator CBegin() const { return _start; }
		ConstIterator CEnd() const { return _finish; }

		size_t Size(){ return _finish - _start; }
		size_t Capacity(){ return _endOfStorage - _start; }

		Vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{}
		Vector(int n,const T& value=T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{
			Reserve(n);
			while (n--)
			{
				PushBack(value);
			}
		}

		//這裏如果使用Iterator做迭代器，就會導致初始化迭代器區間[first,last]只能是Vectord 迭代器
		//這裏重新聲明迭代器，迭代器區間[first,last]可以是任意容器的迭代器區間
		template<class InputIterator>
		Vector(InputIterator first,InputIterator last)
		{
			Reserve(last - first);
			while (first != last)
			{
				PushBack(*first);
				++first;
			}
		}
		Vector( Vector<T>&v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endOfStorage(nullptr)
		{

			Reserve(v.Capacity());//重新申請空間，進行深拷貝
			Iterator it = Begin();
			Iterator vit = v.Begin();
			//ConstIterator vit = v.CBegin();
			while (vit != v.CEnd())
			{
				*it++ = *vit++;
			}
			size_t xx = v.Size();
			_finish = _start + xx;
			_endOfStorage = _start + v.Capacity();
		}

		Vector<T>& operator=(Vector<T> v)
		{
			Swap(v);
			return *this;
		}
		~Vector()
		{
			delete[] _start;
			_start = _finish = _endOfStorage = nullptr;
		}

		void Reserve(size_t n)
		{
			if (n > Capacity())
			{
				size_t size = Size();
				T* tmp = new T[n];

				if (_start)
				{
					for (size_t i = 0; i < size; i++)
					{
						tmp[i] = _start[i];
					}
				}
				_start = tmp;
				_finish = _start + size;
				_endOfStorage = _start + n;
			}
		}

		void Resize(size_t n,const T& value=T())//const T& value=T()默認參數值
		{
			//1.如果n小於當前的size，則數據個數縮小到n
			if (n < Size())
			{
				_finish = _start + n;
				return;
			}
			//2.空間不夠則增容
			if (n>Capacity())
			{
				Reserve(n);
			}
			//先擴容然後給值
			//3.將size擴大到n
			Iterator it = _finish;
			Iterator _finish = _start + n;
			while (it != _finish)
			{
				*it = value;
				++it;
			}
		}
		void Swap(Vector<T>& v)
		{
			swap(_start, v._start);
			swap(_finish, v._finish);
			swap(_endOfStorage, v._endOfStorage);
		}
		void PushBack(const T&x)
		{
			Insert(End(), x);
		}
		void PopBack()
		{
			Erase(--End());
		}
		Iterator Insert(Iterator pos, const T& x)
		{
			assert(pos <= _finish);
			//空間不夠先增容
			if (_finish == _endOfStorage)
			{
				size_t size = Size();
				size_t newCapacity = Capacity() == 0 ? 1 : Capacity() * 2;
				Reserve(newCapacity);

				//如果發生了增容，就需要重置pos
				pos = _start + size;
			}

			//搬移
			Iterator end = _finish - 1;//此時end爲最後一個元素
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;
			++_finish;
			return pos;

		}
		//返回刪除數據的下一個數據
		//方便解決：一遍一遍刪除迭代器失效問題
		Iterator Erase(Iterator pos)
		{
			//挪動數據進行刪除
			Iterator begin = pos + 1;
			while (begin != _finish)
			{
				*(begin - 1) = *begin;
				begin++;
			}
			--_finish;
			return pos;
		}
		T& operator[](size_t pos)
		{
			return _start[pos];
		}

	private:
		Iterator _start;//指向數據塊的開始
		Iterator _finish;//指向有效數據的尾
		Iterator _endOfStorage;//指向存儲容量的尾
	};
}


void TestVector1()
{
	bit::Vector<int> first;
	bit::Vector<int> second(4, 100);
	bit::Vector<int> third(second);
	bit::Vector<int> fourth(third);
	cout << second[1] << endl;

	int myints[] = {16,2,77,29};
	bit::Vector<int> fifth(myints, myints + sizeof(myints) / sizeof(int));//數組轉vector
	cout << "The contents of fifth are:"<<endl;
	for (bit::Vector<int>::Iterator it = fifth.Begin(); it != fifth.End(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
	//測試T是string時，拷貝問題
	bit::Vector<string> strV;

	strV.PushBack("1111");
	strV.PushBack("2222");
	strV.PushBack("3333");
	strV.PushBack("4444");
	for (size_t i = 0; i < strV.Size();i++)
	{
		cout << strV[i] << " ";
	}
	cout << endl;
}

//vector iterator的使用
void PrintVector(const bit::Vector<int>& v)
{
	//使用const迭代器進行遍歷打印
	bit::Vector<int>::ConstIterator it = v.CBegin();
	while (it != v.CEnd())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
}

void TestVector2()
{
	//使用push_back插入4個元素
	bit::Vector<int> v;
	v.PushBack(1);
	v.PushBack(2);
	v.PushBack(3);
	v.PushBack(4);

	//使用迭代器進行遍歷打印
	bit::Vector<int>::Iterator it = v.Begin();
	while (it != v.End())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;

	//使用迭代器進行修改
	it = v.Begin();
	while (it != v.End())
	{
		*it *= 2;
		++it;
	}
	PrintVector(v);
}
//capacity/vector::reserve/resize
void TestVector3()
{
	size_t sz;
	bit::Vector<int> foo;
	sz = foo.Size();
	cout << "making foo grow:\n";
	for (int i = 0; i < 100; i++)
	{
		foo.PushBack(i);
		if (sz != foo.Capacity())
		{
			sz = foo.Capacity();
			cout << "capacity changed:" << sz << endl;
		}
	}

	//resize
	bit::Vector<int> myvector;
	//set some inital content:
	for (int i = 1; i < 10; i++)
	{
		myvector.PushBack(i);
	}
	myvector.Resize(5);
	myvector.Resize(8, 100);
	myvector.Resize(12);

	cout << "myvector contains:";
	for (size_t i = 0; i < myvector.Size(); i++)
	{
		cout << myvector[i] << " ";
	}
	cout << "\n";
}
void TestVector4()
{
	int a[] = { 1, 2, 3, 4 };
	bit::Vector<int> v(a, a + sizeof(a) / sizeof(int));

	//使用find查找3所在的位置
	bit::Vector<int>::Iterator pos = find(v.Begin(), v.End(),3);

	//刪除pos位置的數據
	v.Erase(pos);
	//發現可以進行訪問
	//因爲編寫代碼的時候進行了處理，返回了pos下一個元素的值
	cout << *pos << endl;

}
int main()
{
	//TestVector1();
	//TestVector2();
	//TestVector3();
	TestVector4();

	return 0;
}

基本上是沒有什麼大問題，在reserve上，沒有進行舊空間的釋放，但解決了迭代器失效問題。