模拟实现vector

vector的基本使用

容器
string ——近容器
int arr[10]
char str[10]

vector ——真正的容器——当作数组来用

• v.resize(),增加数组容量，新增加的用默认值0填充；减少数组元素时会将元素清除掉。
• v.reverse(),扩容，不改变数组元素。
• max_size()， 当前数组元素最多能填充的数据。

void show(vector<int>& v)
{
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}
int main()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);//尾插
	}
	show(v1);

	v1.resize(20);//总的数据长度增加到20，新增加的部分用默认值0填充
	show(v1);

	v1.resize(5);//将长度变为5
	show(v1);

	v1.reserve(10);//扩容,打印的数据无变化
	show(v1);
	cout << v1.max_size()<<endl;

	v1.pop_back();//尾删
	show(v1);

	cout << v1.back();//输出最后一个元素
}

使用模板实现vector

#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;
		_arr = NULL;
	}

	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];
		memset(arr, 0, sizeof(T) * len);
		for (int i = 0; i < len && i < _val_len; i++)
		{
			arr[i] = _arr[i];
		}
		delete[]_arr;
		_val_len = len;
		_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 _len == _val_len;
	}
	T*  _arr;
	int _len;
	int _val_len;
};

#endif