一、容器

1. 近容器：只能容纳一种固定的数据类型的“器皿”（如string、int arr[10]、char str[10]）
2. 容器：vector——数组
3. 格式：

   vector<int> v1;
   for(int i=1;i<10;i++)
   {
       v1.push_back(i);
   }

4. 实现

   //Mvector.h
   #ifndef MVECTOR_H
   #define MVECTOR_H
   
   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 < _val_len; i++)
   			{
   				_arr[i] = src._arr[i];
   			}
   		}
   	}
   
   	~Mvector()
   	{
   		delete[]_arr;
   	}
   
   	Mvector& operator=(const Mvector& src)
   	{
   		//防止自赋值
   		if (this == &src)
   		{
   			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--;
   	}
   
       T back()const
   	{
   		if (empty())
   		{
   			return -1;
   		}
   		return _arr[_val_len - 1];
   	}
   
   	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;
   	}
   
   	T& operator[](int pos)
   	{
   		return _arr[pos];
   	}
   
   	T operator[](int pos)const
   	{
   		return _arr[pos];
   	}
   private:
   	bool full()
   	{
   		return _val_len == _len;
   	}
   	T* _arr;
   	int _len;
   	int _val_len;
   };
   
   #endif