C++容器---vector总结

1.vector介绍

    1.vector是表示可变大小数组的序列容器；

    2.就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理；

    3.本质讲，vector使用动态分配数组来存储它的元素，当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间，其做法是，分配一个新的数组，然后将全部元素移到这个数组，就时间而言，这还是一个相对代价高的任务，因为每当一个新的元素加入容器的时候，vector并不会每次都从新分配大小；

    4.vector分配空间资源策略：vector会分配一些额外空间适应可能的增长，因为存储空间比实际需要的存储空间更大，不同是库采用不同的策略权衡空间的使用和重新分配，但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个新的元素的时候是在常数时间的复杂度完成的；

    5.因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长；

    6.与其他动态序列容器相比，vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效，对于其他不在末尾的删除和插入操作，效率更低。 

2.vector的使用

    1.vector的定义

      

    2.vector iterator的使用

       

    3.vector空间增长问题

      

    ·capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。因为vs是pj版本STL，g++是SGI版本STL。

    ·reserve只负责开辟空间，如果确定知道需要多少空间，reserve可以缓解vector增容的代价缺陷问题。

    ·resize在开辟空间的同时还会进行初始化，影响size。

    4.vector增删改查

       

      5.vector迭代器失效问题

          1.insert时导致迭代器失效：因为insert时有可能引起增容，增容后原来空间被释放，重新开辟一块空间存放数据，所以原有的迭代器失效，需要重新获取迭代器。（如果insert时没有引起增容就不会出现迭代器失效）

          2.erase时导致迭代器失效：因为删除当前迭代器所指向的元素，迭代器将自动指向下一个元素，如果删除的是最后一个迭代器位置的元素，将会引起迭代器失效，所以每次删除迭代器之后重新赋值就可以。

3.vector的模拟实现

#include <iostream>
#include <string>
#include <assert.h>
#include <stdlib.h>

using namespace std;

template <class T>
class Vector{
	typedef T* iterator;
	typedef const T* const_iterator;
public:
	//构造函数
	Vector() 
		:_start(nullptr)
		, _finish(nullptr)
		, _endOfStorage(nullptr)
	{}

	//析构函数
	~Vector() {
		if (_start){
			delete[] _start;
			_start = _finish = _endOfStorage = nullptr;
		}
	}

	//尾插
	void PushBack(const T& val) {
		if (_start){
			size_t newCapacity = _start == _finish ? 1 : 2 * Capacity();
			Reserve(newCapacity);
		}
		*_finish++ = val;
		Insert(end(), val);
	}

	//拷贝构造
	Vector(const Vector<T>& v) {
		//考虑深拷贝
		//开空间
		//拷贝
		_start = new T[v.Capacity()];
		for (int i = 0; i < v.Size(); i++){
			_start[i] = v[i];
		}
		_finish = _start + v.Size();
		_endOfStorge = _start + v.Capaciyt();
	}

	//赋值运算符重载
	Vector<T>& operator=(const Vector<T>& v) {
		//检查是否自己赋值
		//返回值类型：引用，为了连续赋值
		//返回：*this
		if (this != &v){
			T *tmp = new T[v.Capacity()];
			for (int i = 0; i < v.Size(); i++){
				tmp[i] = v[i];
			}

			if (_start)
				delete[] _start;
			_start = tmp;
			_finish = _start + v.Size();
			_endOfStorage = _start + v.Capacity();
		}
	}

	Vector<T>& operator=(const Vector<T> v) {
		Swap(v);
		return *this;
	}

	void Swap(Vector<T>& v) {
		swap(_start, v._start);
		swap(_finish, v._start);
		swap(_endOfStorage, v._endOfStorage);
	}

	//扩容
	void Reserve(const size_t& n) {
		if (n > Capacity()){
			int len = Size();
			
			T* tmp = new T[n];

			//这里直接使用memcpy是有问题的
			//memcpy：值拷贝，浅拷贝
			//对于自定义类型（含有资源），可能会引发空间二次释放
			//if (_start)
			//	memcpy(tmp, _start, sizeof(T)*len);
			if (_start){
				for (int i = 0; i < len; i++){
					tmp[i] = _start[i];
				}	
			}
			_start = tmp;
			_finish = _start + len;
			_endOfStorage = _start + n;
		}	
	}

	//Resize设置有效值的个数
	void Resize(size_t n, const T& val = T()) {
		if (n <= Size()){
			_finish = _start + n;
		}else{
			if (n > Capacity())
				Reserve(n);
			//新增位置赋值
			while (_finish != _start + n){
				*_finish = val;
				++_finish;
			}
		}
	}

	//尾删
	void PopBack() {
		Erase(end() - 1);
	}

	//可读可写
	T& operator[](size_t pos) {
		assert(pos < Size());
		return _start[pos];
	}

	//返回容量
	size_t Capacity() const {
		return _endOfStorage - _start;
	}

	//判空
	bool Empty() {
		return _start == _finish;
	}

	//返回有效值的个数
	size_t Size() const{
		return _finish - _start;
	}

	//迭代器
	//可读可写
	//begin
	iterator begin() {
		return _start;
	}

	//end
	iterator end() {
		return _finish;
	}

	//只读
	//begin
	const_iterator begin() const{
		return _start;
	}

	//end
	const_iterator end() const {
		return _finish;
	}

	//插入
	iterator Insert(iterator pos, const T& val) {
		assert(pos <= _finish && pos >= _start);
		size_t len = pos - _start;
		//检查空间是否够用
		if (_finish == _endOfStorage){
			size_t newC = _start == nullptr ? 1 : 2 * Capacity();
			Reserve(newC)
		}
		//增容之后，更新迭代器
		pos = _start + len;
		iterator end = _finish;
		//从后面向前挪动元素，腾出pos的空间，存放新的元素val
		while (end > pos){
			*end = *(end - 1);
			end--;
		}

		*pos = val;
		++_finish;
		return pos;
	}

	//返回删除数据的下一个数据
	//方便解决：一边遍历一边删除的迭代器失效问题
	iterator Erase(iterator pos) {
		assert(pos < _finish && pos >= _start);
		iterator begin = pos + 1;
		//从pos+1依次向前挪动元素
		while (begin < _finish){
			*(begin - 1) = *beign;
			++begin;
		}

		--_finish;
		return pos;
	}
	
private:
	T* _start;
	T* _finish;
	T* _endOfStorage;
};