模板实现vector

容器

容器就是用来装东西的物体，什么都可以装。
C/C++语言中实现的容器都是依赖于数据结构实现的，比如依赖于链表，栈，字符串，队列等实现的容器，后期有依赖红黑树实现的set,map等等。

近容器

String就是一种近容器。Sting 虽然属于容器，但是它与容器的概念是背离的。容器可以装所有东西，但是String只可以装字符串。
同样的近容器还有：
int arr[10]
char str[10];
这些容器可以存放固定的数据类型

vector

vector的用法相当于数组
vectorv1;

void show(vector<int>& v)
{
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << "  ";
	}
	cout << endl;
}

//vector------容器------数组
	vector<int>v1;
	int a = int();//整型默认构造==int a=0;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}

vector.resize()

v1.resize(20);//容器大小为20，容器里面的数据个数也为20；即便数据个数不够20，也会自动填充当前数据类型的默认值。缩容也是一样，超过的数据直接不要，容器大小是多少，数据个数就是多少

	show(v1);

	v1.resize(20);//扩容，旧数据依然在，增加的空间会填充成当前类型的默认值
	show(v1);

	v1.resize(5);
	show(v1);

vector.reserve()

v1.reserve(5);//容器实际大小为10，此时扩容为15，容器大小变为15，但是数据个数依旧为10。缩容不改变容器大小和数据长度。实际数据个数不变，只是改变容器大小。

	show(v1);
	v1.reserve(15);
	show(v1);

	v1.reserve(5);
	show(v1);

#include<iostream>
#include<string>
using namespace std;



template<typename T>
class Mvector
{
public:
	Mvector()
	{
		_arr = NULL;
		_len = 0;
		_val_len = 0;
	}
	Mvector(const Mvector& src)
	{
		if (NULL == src._arr)
		{
			_arr = src._arr;
			_len = src._len;
			_val_len = src._val_len;
		}
		else
		{
			_len = src._len;
			_val_len = src._val_len;
			_arr = new T[_len];
			for (int i = 0; i < _len; i++)
			{
				_arr[i] = src._arr[i];
			}
		}
	}
	~Mvector()
	{
		delete[]_arr;
	}

	Mvector& operator=(const Mvector& src)//为什么返回引用：引用底层是一个指针，相当于返回一个指针；如果返回对象，相当于拷贝构造一个临时对象返回，最后还要析构临时对象，该过程即浪费时间又浪费空间
	{
		//防止自赋值
		if (&src==this)
		{
			return *this;
		}
		//防止内存泄漏
		if (NULL != _arr)
		{
			delete[]_arr;
		}
		//防止浅拷贝
		_len = src._len;
		_val_len = src._val_len;
		if (NULL != src._arr)
		{
			_arr = new T[_len];
		}
		else
		{
			_arr = NULL;
		}
		for (int i = 0; i < _val_len; i++)
		{
			_arr[i] = src._arr[i];
		}
		return *this;
	}
	void push_back(const T& val)
	{
		if (full())
		{
			if (_len == 0)
			{
				_len = 1;
			}
			int len = _len << 1;
			reserve(len);
		}
		_arr[_val_len] = val;
		_val_len++;
	}
	void pop_back()
	{
		if (empty())
		{
			return;
		}
		_val_len--;
	}
	int size()const
	{
		return _val_len;
	}
	void resize(int len)
	{
		if (len < 0)
		{
			len = 0;
		}
		if (len == 0)
		{
			delete[]_arr;
			_len = 0;
			_val_len = 0;
			return;
		}

		T* arr = new T[len](0);
		for (int i = 0; i < len && i < _val_len; i++)
		{
			arr[i] = _arr[i];
		}
		delete[]_arr;
		_arr = arr;
	}
	void reserve(int len)
	{
		if (len <= _val_len)
		{
			return;
		}
		_len = len;
		T *arr= new T[_len];
		for (int i = 0;i < _val_len; i++)
		{
			arr[i] = _arr[i];
		}
		delete[]_arr;
		_arr = arr;
	}
	bool empty()const
	{
		return _val_len == 0;
	}
	bool full()const
	{
		if (_len == _val_len)
		{
			return true;
		}
		return false;
	}

	T& operator[](int pos)
	{
		return _arr[pos];
	}
	T operator[](int pos)const
	{
		return _arr[pos];
	}
private:
	T* _arr;
	int _len;
	int _val_len;
};

不加空间配置器的vector

问题：

解决：使用空间配置器

结果