顺序容器——vector

一、底层实现

vector就是动态数组.它也是在堆中分配内存,元素连续存放,有保留内存,如果减少大小后，内存也不会释放.如果新值>当前大小时才会再分配内存.

它拥有一段连续的内存空间，并且起始地址不变，因此它能非常好的支持随即存取，即[]操作符，但由于它的内存空间是连续的，所以在中间进行插入和删除会造成内存块的拷贝，另外，当该数组后的内存空间不够时，需要重新申请一块足够大的内存并进行内存的拷贝。这些都大大影响了vector的效率。

对最后元素操作最快(在后面添加删除最快 ), 此时一般不需要移动内存,只有保留内存不够时才需要

对中间和开始处进行添加删除元素操作需要移动内存,如果你的元素是结构或是类,那么移动的同时还会进行构造和析构操作，所以性能不高 （最好将结构或类的指针放入vector中，而不是结构或类本身，这样可以避免移动时的构造与析构)。
访问方面,对任何元素的访问都是O(1),也就是是常数的,所以vector常用来保存需要经常进行随机访问的内容,并且不需要经常对中间元素进行添加删除操作.

二、模拟实现（主要实现了个别接口函数和迭代器）

1.MyVector.h

#ifndef MYVECTOR_H
#define MYVECTOR_H

#include<iostream>
#include"Myiterator.h"
using namespace std;

template<typename T>
class MyVector
{
public:
	typedef Myiterator<T> iterator;

	MyVector()      //构造函数
	{
		_arr = NULL;
		_valSize = 0;
		_len = 0;
	}

	MyVector(const MyVector& src)  //拷贝构造函数 
	{
		if (0 == src._len)
		{
			_arr = NULL;
			_valSize = 0;
			_len = 0;

			return;
		}

		_arr = new T[src._valSize];
		for (int i = 0; i<src._valSize; i++)
		{
			_arr[i] = src._arr[i];
		}
	}

	MyVector& operator=(const MyVector &src)   //=运算符重载 
	{
		/*1.防止自赋值
		2.防止内存泄漏
		3.防止浅拷贝*/
		if (this == src)
		{
			return *this;
		}

		if (NULL != _arr)
		{
			delete[] _arr;
		}

		if (0 == src._valSize)
		{
			_arr = NULL;
			_valSize = 0;
			_arr = 0;

			return;
		}

		_arr = new T[src._valSize];
		for (int i = 0; i<src._valSize; i++)
		{
			_arr[i] = src._arr[i];
		}

		return *this;
	}

	~MyVector()          //析构函数 
	{
		if (NULL != _arr)
		{
			delete[] _arr;
		}
	}

	T& operator[](int pos)   //[]运算符重载 
	{
		return 	_arr[pos];
	}

	void push_back(const T&val)  //添加值为val的元素到当前vector末尾
	{
		if (full())
		{
			dilatation();
		}

		_arr[_valSize++] = val;
	}

	void pop_back()           //删除当前vector最末的一个元素
	{
		if (!empty())
		{
			_valSize--;
		}
	}

	T front()                 //返回当前vector起始元素的引用
	{
		if (!empty())
		{
			return _arr[0];
		}
		throw "vector is empty!";
	}

	T back()                  //返回当前vector最末一个元素的引用
	{
		if (!empty())
		{
			return _arr[_valSize - 1];
		}
		throw "vector is empty!";
	}

	int size()                //返回当前vector所容纳元素的数目
	{
		return _valSize;
	}

	void clear()              //删除当前vector中的所有元素
	{
		_valSize = 0;
	}

	void reserve(int len)   //为当前vector预留至少共容纳size个元素的空间
	{
		if (len < _len)
		{
			return;
		}

		T* p = new T[len];
		for (int i = 0; i<_valSize; i++)
		{
			p[i] = _arr[i];
		}

		if (NULL != _arr)
		{
			delete[] _arr;
		}

		_arr = p;
		_len = len;
	}

	bool empty()      //如果当前vector没有容纳任何元素,则empty()函数返回true,否则返回false
	{
		return _valSize == 0;
	}

	bool full()      //判满 
	{
		return _valSize == _len;
	}

	void show()
	{
		for (int i = 0; i<_valSize; i++)
		{
			cout << _arr[i] << " ";
		}
		cout << endl;
	}

	iterator begin()
	{
		return iterator(this, 0);
	}

	iterator end()
	{
		return iterator(this, _valSize);
	}

private:
	T* _arr;
	int _valSize;   //现在存储位置 
	int _len;       //总大小

	void dilatation()  //扩容函数 
	{
		if (_len == 0 || _len == 1)
		{
			_len++;
		}

		_len = _len + (_len >> 1);  //采用1.5倍扩容方式

		T* p = new T[_len];

		for (int i = 0; i<_valSize; i++)
		{
			p[i] = _arr[i];
		}

		if (NULL != _arr)
		{
			delete[] _arr;
		}
		_arr = p;
	}
};

template<typename T>
T& Myiterator<T>::operator*()
{
	return (*_vec)[_pos];
}

template<typename T>
T& Myiterator<T>::operator->()
{
	return (*_vec)[pos];
}

#endif;

2.Myiterator.h

#ifndef MYITERATOR_H
#define MYITERATOR_H
#include<iostream>
using namespace std;

template<typename T>
class MyVector;

template<typename T>
class Myiterator
{
private:
	MyVector<T>* _vec;
	int _pos;
public:
	Myiterator(MyVector<T>* src, int pos)
	{
		_vec = src;
		_pos = pos;
	}

	Myiterator(const Myiterator*src)
	{
		_vec = src._vec;
		_pos = src._pos;
	}

	Myiterator& operator=(const Myiterator& src)
	{
		_vec = src._vec;
		_pos = src._pos;
	}

	bool operator==(const Myiterator& src)
	{
		return (_vec == src._vec && _pos == src._pos);
	}

	bool operator!=(const Myiterator& src)
	{
		return (_vec != src._vec || _pos != src._pos);
	}

	Myiterator& operator++()   //后置++
	{
		++_pos;
		return *this;
	}

	Myiterator operator++(int)
	{
		return Myiterator(_vec, _pos++);
	}

	Myiterator&  operator--()
	{
		--pos;
		return *this;
	}

	Myiterator& operator--(int)
	{
		return Myiterator(_vec, _pos--);
	}

	T& operator*();
	T& operator->();
};

#endif;

3.main.cpp

#include"MyVector.h"
#include<iostream>

using namespace std;

int main()
{
	MyVector<int> v1;
	v1.reserve(5);

	for (int i = 0; i<10; i++)
	{
		v1.push_back(i);
	}
	v1.show();

	cout <<v1.back() << endl;
	cout << v1.front() << endl;

	v1.pop_back();
	v1.show();

	MyVector<int> ::iterator it = v1.begin();
	for (it; it != v1.end(); it++)
	{
		cout <<*it << "    ";
	}
	cout << endl;

	return 0;
}

三、运行结果