vector的介绍与模拟实现

1.vector的介绍及使用
1.1 vector的介绍
vector介绍
1. vector是表示可变大小数组的序列容器。
2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大
小。
4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
6. 与其它动态序列容器相比（deques, lists and forward_lists）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起lists和forward_lists统一的迭代器和引用更好。

2. vector模拟实现

#include<algorithm>
#include<list>
#include<iostream>
#include<assert.h>
using namespace std;
struct A
{
public:
	A(int a = 1)
		:_a(a)
	{
		cout << "A(int)" << endl;
	}
private:
	friend ostream& operator<<(ostream& out, const A& a);
	int _a;
};

ostream& operator<<(ostream& out, const A& a)
{
	out << a._a;
	return out;
}

template <class T>
class Vector
{
public:
	//迭代器类型：T*
	typedef T* iterator;
	typedef const T* const_iterator;

	Vector()
		:_start(nullptr)
		, _finish(nullptr)
		, _endofStorage(nullptr)
	{}

	Vector(size_t n, const T& val = T())
		:_start(new T())
		, _finish(_start + n)
		, _endofStorage(_start + n)
	{
		for (size_t i = 0; i < n; i++)
		{
			_start[i] = val;
		}
	}

	template<class InputIterator>
	Vector(InputIterator first, InputIterator last)
		:_start(nullptr)
		, _finish(nullptr)
		, _endofStorage(nullptr)
	{
		while (first != last)
		{
			pushback(*first);
			++first;
		}
	}

	void pushBack(const T& val)
	{
		//检查容量
		if (_finish == _endofStorage)
		{
			size_t newC = _endofStorage == nullptr ? 1 : 2 * capacity();
			reserve(newC);
		}
		//插入
		*_finish = val;
		//更新
		++_finish;
	}

	void reserve(size_t n)
	{
		if (n > capacity())
		{
			//保存元素个数
			size_t sz = size();
			//申请空间
			T* tmp = new T[n];
			//拷贝内容
			if（_start)
			{
			    //拷贝有效元素
				memcpy(tmp, _start, sizeof(T) * size());
				//释放原有的空间
				delete[] _start;
            }
			//更新
			_start = tmp;
			//错误写法
			//_finish = start + size();
			_finish = _start + sz;
			_endofStorage = _start + n;
		}
	}

	size_t size() const
	{
		return _finish - _start;
	}

	size_t capacity() const
	{
		return _endofStorage - _start;
	}

	iterator begin()
	{
		return _start;
	}

	iterator end()
	{
		return _finish;
	}

	const_iterator begin() const
	{
		return _start;
	}

	const_iterator end() const
	{
		return _finish;
	}

	T& operator[](size_t pos)
	{
		assert(pos < size());
		return _start[pos];
	}

	const T& operator[](size_t pos) const
	{
		assert(pos < size());
		return _start[pos];
	}

	void resize(size_t n, const T& val = T())
	{
		//n > capacity
		if (n > capacity())
		{
			reserve(n);
		}
		//size < n <= capacity
		if (n > size())
		{
			//[size,n):填充val
			while (_finish != _start + n)
			{
				*_finish = val;
				++_finish;
			}
		}
		//n <= size
		_finish = _start + n;
	}

	void insert(iterator pos, const T& val)
	{
		//检查位置[_start,_finish]
		assert(pos >= _start && pos <= _finish);
		//检查容量
		if (_finish == _endofStorage)
		{
			//增容会导致迭代器失效
			//保存pos和_start的偏移量
			size_t offset = pos - _start;

			size_t newC = _endofStorage == nullptr ? 1 : 2 * capacity();
			reserve(newC);

			//更新pos
			pos = _start + offset;
		}
		//移动元素：从后向前
		iterator end = _finish;
		while (end != pos)
		{
			*end = *(end - 1);
			--end;
		}
		//插入
		*pos == val;
		//更新
		++_finish;
	}

	void erase(iterator pos)
	{
		//检查范围
		assert(pos >= _start && pos <= _finish);
		//元素移动：从前向后移动
		iterator start = pos + 1;
		while (start != _finish)
		{
			//第一次pos+1 --> pos
			//最后一次: _finish - 1 ---> _finish - 2
			*(start - 1) = *start;
			++start;
		}
		//更新
		--_finish;
	}

	//尾删
	void popBack()
	{
		if (size() > 0)
		{
			erase(end() - 1);
		}
	}

	~Vector()
	{
		if (_start)
		{
			delete[] _start;
			_start = _finish = _endofStorage = nullptr;
		}
	}

private:
	//_start:第一个元素的首地址
	iterator _start;
	//_finfish:最后一个元素的结尾
	iterator _finish;
	//_endofStorage:空间的结尾
	iterator _endofStorage;
};


//函数模板
template<class T>
void printVector(Vector<T>& vec,const T& val)
{
	Vector<T>::iterator it = vec.begin();
	while (it != vec.end())
	{
		cout << *it << " ";
		*it = val;
		++it;
	}
	cout << endl;
}

template<class T>
void printVector(const Vector<T>& vec)
{
	Vector<T>::const_iterator it = vec.begin();
	while (it != vec.end())
	{
		cout << *it << " ";
		//只读操作，不允许修改
		++it;
	}
	cout << endl;
}


template<class T>
void printVectorFor(Vector<T>& vec,const T& val)
{
	for (const auto& e : vec)
	{
		cout << e << " ";
		e = val;
	}
	cout << endl;
}

template<class T>
void printVectorFor(const Vector<T>& vec)
{
	for (const auto& e : vec)
	{
		cout << e << " ";
		//e = val;
	}
	cout << endl;
}

template <class T>
void printOperator(Vector<T>& vec, const T& val)
{
	for (size_t i = 0, i < vec.size(); i++)
	{
		cout << vec.operator[](i) << " ";
		vec[i] = val;
	}
	cout << endl;
}

template <class T>
void printOperator(const Vector<T>& vec)
{
	for (size_t i = 0, i < vec.size(); i++)
	{
		cout << vec.operator[](i) << " ";
	}
	cout << endl;
}