C++：vector模板

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
#include<string>
using namespace std;
namespace Vector
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;

	public:
		//构造
		vector()
			:start(nullptr),finish(nullptr),endofstorage(nullptr)
		{}
		vector(int n, const T& val = T())
		{
			start = new T[n];
			for (size_t i = 0; i < n; i++)
				start[i] = val;
			finish = start + n;
			endofstorage = finish;
		}

		template<class Iterator>
		vector(Iterator first, Iterator last)
		{
			auto it = first;
			int n = 0;    //个数
			while (it != last)
			{
				it++;
				n++;
			}
			start = new T[n];
			finish = start;
			while (first != last)
			{
				*finish = *first;
				first++;
				finish++;
			}
			endofstorage = finish;
		}
		vector(const vector<T>& v)
		{
			size_t n = v.size();
			start = new T[n];
			for (int i = 0; i < n; i++)
				start[i] = v[i];
			finish = start + n;
			endofstorage = finish;
		}
		vector<T>& operator=(vector<T> v)
		{
			this->swap(v);
			return *this;
		}
		~vector()
		{
			if (start)
			{
				delete[] start;
				start = finish = endofstorage = nullptr;
			}
		}
		//迭代器
		iterator begin()
		{
			return start;
		}
		iterator end()
		{
			return finish;
		}
		//容量
		size_t size()const
		{
			return finish - start;
		}
		size_t capacity()const
		{
			return endofstorage - start;
		}
		bool empty()const
		{
			return start == finish;
		}
		void resize(size_t newsize, const T& val)
		{
			size_t oldsize = size();
			if (newsize > oldsize)
			{
				size_t cap = capacity();
				if (newsize > cap)//判断容量是否充足
					reserve(newsize);
				for (int i = oldsize; i < newsize; i++)
				{
					start[i] = val;
				}
			}
			finish = start + newsize;
		}
		void resize(size_t newsize)
		{
			resize(newsize, '\0');
		}
		void reserve(size_t newcapacity)//扩容
		{
			size_t oldCap = capacity();
			if (newcapacity > oldCap)
			{
				//开辟空间
				T* temp = new T[newcapacity];
				if (start)//判断旧空间是否存在
				{
					//拷贝元素
					
					//memcpy(temp, start, sizeof(T) * size());
			    //  memcpy为浅拷贝，若vector放置元素涉及资源管理时，出现内存泄漏
			    //  例：string类
					for (int i = 0; i < size(); i++)
						temp[i] = start[i];
					//释放旧空间
					delete[] start;
				}
			    
				int sz = size();//提前记录
				start = temp;//start进入新空间
				//finish = start + size();  size()中start与finish不在同一空间
				finish = start + sz;
				endofstorage = start + newcapacity;
			}
		}
		//元素访问
		//起始元素
		T& front()
		{
			return *start;
		}
		const T& front()const
		{
			return *start;
		}
		//末尾元素
		T& back()
		{
			return *(finish - 1);
		}
		const T& back()const
		{
			return *(finish - 1);
		}
		T& operator[](size_t index)
		{
			assert(index < size());
			return start[index];
		}
		const T& operator[](size_t index)const
		{
			assert(index < size());
			return start[index];
		}

		T& at(size_t index)
		{
			if (index >= size())
			{
				throw out_of_range("vector 越界");
			}
			return start[index];
		}
		const T& at(size_t index)const
		{
			if (index >= size())
			{
				throw out_of_range("vector 越界");
			}
			return start[index];
		}
		//修改
		void push_back(const T& val)//尾插
		{
			//检测空间是否足够
			if (finish == endofstorage)
				reserve(capacity() * 1.5 + 3);//扩容
			*finish = val;
			finish++;
		}
		void pop_back()//尾删
		{
			if (empty())
				return;
			finish--;
		}
		//任意位置插入和删除
		iterator insert(iterator pos, const T& val)
		{
			if (pos<begin() || pos>end())//出界
				return end();
			if (finish == endofstorage)
				reserve(capacity() * 1.5);
			auto it = finish - 1;
			while (it >= pos)//将pos之后元素向后搬移
			{
				*(it + 1) = *it;
				it--;
			}
			*pos = val;
			finish++;
			return pos;//返回pos迭代器
		}
		iterator erase(iterator pos)
		{
			if (empty())
				return end();
			if (pos < begin() || pos >= end())
				return end();
			auto it = pos + 1;
			while (it != end())
			{
				*(it - 1) = *it;
				it++;
			}
			finish--;
			return pos;
		}
		iterator erase(iterator first, iterator last)
		{
			//删除 [ firsst , last )
			auto it = first;
			auto pos = last;
			int n = last - first;//删除元素个数
			while (pos != end())
			{
				*it = *pos;
				it++;
				pos++;
			}
			finish -= n;
			return first;//返回last值
		}
		void clear()
		{
			erase(begin(), end());
		}
		void swap(vector<T>& v)
		{
			std::swap(start, v.start);
			std::swap(finish, v.finish);
			std::swap(endofstorage, v.endofstorage);
		}
	private:
		iterator start;//起始位置   begin()
		iterator finish;//末尾元素的下一个位置   end()
		iterator endofstorage;//空间的末尾
	};
}

void TestVector01()
{
	Vector::vector<int> v1;
	Vector::vector<int> v2(10, 5);

	int array[] = { 1,2,3,4,5,6,7,8 };
	Vector::vector<int> v3(array, array + sizeof(array) / sizeof(array[0]));

	Vector::vector<int> v4(v3);

	for (int i = 0; i < v2.size(); i++)
		cout << v2[i] << " ";
	cout << endl;

	for (auto e : v3)
		cout << e << " ";
	cout << endl;

	auto it = v4.begin();
	while (it != v4.end())
	{
		cout << *it << " ";
		it++;
	}

}

template<class T>
void PrintVector(const Vector::vector<T>& v)
{
	for (int i = 0; i < v.size(); i++)
		cout << v[i] << " ";
	cout << endl;
}

void TestVector02()
{
	Vector::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	cout << v.size() << endl;
	cout << v.capacity() << endl;

	v.resize(10, 6);
	PrintVector(v);
	v.resize(20, 10);
	PrintVector(v);

	v.resize(10);
	PrintVector(v);
	v.resize(15);
	PrintVector(v);
}

void TestVector03()
{
	Vector::vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);

	cout << v.front() << endl;//起始
	cout << v.back() << endl;//末尾
	cout << v[4] << endl;
//	cout << v.at(5) << endl;

	v.insert(v.begin(), 100);
	PrintVector(v);

	v.erase(v.begin());
	PrintVector(v);

	v.erase(v.begin(), v.begin() + 3);
	PrintVector(v);

	v.clear();
	if (v.empty())
		cout << "v 清理完毕!!" << endl;
	else
		cout << "v.clear()失败" << endl;

}

void TestVector04()
{
	Vector::vector<Vector::vector<int>> vv(5, Vector::vector <int>(6, 8));
	for (int i = 0; i < vv.size(); i++)
	{
		for (int j = 0; j < vv[i].size(); j++)
			cout << vv[i][j] << " ";
		cout << endl;
	}
		
}

class Date
{
public:
	Date(int year=1900,int month=1,int day=1)
		:_year(year),_month(month),_day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

void TestVectorDate()
{
	Vector::vector<Date> v;
	v.push_back(Date(2001, 10, 28));
	v.push_back(Date(2011, 10, 28));
	v.push_back(Date(2021, 10, 28));
	v.push_back(Date(2031, 10, 28));
	
	cout << v.size() << endl;
}

class String
{
public:
	String(const char* str = "")
	{
		if (str == nullptr)
			str = "";
		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}
	~String()
	{
		if (_str)
		{
			delete[] _str;
			_str = nullptr;
		}
	}
	String(const String& s)
		:_str(new char[strlen(s._str)+1])
	{
		strcpy(_str, s._str);
	}
	String& operator=(const String& s)
	{
		if (this != &s)
		{
			char* temp = new char[strlen(s._str) + 1];
			strcpy(temp, s._str);

			delete[] _str;
			_str = temp;
		}
		return* this;
	}
private:
	char* _str;
};

void TestVectorString()
{
	Vector::vector<String> v;
	//内存扩容为3
	v.push_back("111");
	v.push_back("222");
	v.push_back("333");
	cout << v.size() << endl;
	PrintVector(v);
	//内存扩容，使用memcpy浅拷贝  内存泄漏 报错
	v.push_back("444");
	PrintVector(v);
}


int main()
{
//	TestVector01();
//	TestVector02();
//	TestVector03();
//	TestVector04();
	TestVectorString();
}