STL——vector详解

一、vector的使用

1、构造函数

//下面以int类型为模板参数进行演示
//无参构造
vector<int>();

//使用n个值进行构造
vector<int>(5,1);//使用5个1进行构造

//拷贝构造
vector<int> v(5,1);
vector<int>(v);//

2、迭代器iterator

//获取首元素的迭代器
begin();

//获取末尾元素的迭代器的前一个
end();

//反向迭代器
rebegin();//等同于end()
rend();//等同于begin

3、容量操作

//获取元素个数
size();

//获取容量大小
capicity();

//判断是否为空
empty();

//调整空间大小
resize(n,val);//开辟n个空间，并使用val填充，val为缺省参数可省略，省略的话为默认值
reserve(n);//开辟n个空间
//注意：
//resize在开辟空间时如果n<size，会影响数据，size调整为n
//如果n>capicity,size和capicity大小都会变为n

4、增删改查

//尾插
push_back(val);

//尾删
pop_back();

//插入
insert(iterator pos,val);//

//删除
erase(iterator pos);

//交换两个vector的空间
swap(v2);//将当前调用swap的vector对象和v2空间进行交换

//下标访问
operator[](pos);

二、底层实现

	template<class T>
	class vector
	{
	public:
		//迭代器
		typedef T* iterator;
		typedef const T* const_iterator;
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}
		
		//构造
		vector()
		{}
		
		//拷贝构造实现方法1
		vector(const vector<T>& v)
		{
			reserve(v.capacity());
			for (auto& e : v)
			{
				push_back(e);
			}
		}
		//拷贝构造实现方法2
		vector(const vector<T>& v)
		{
			_start = new T[v.capicity()];
			memcpy(_start,v._start,sizeof(T)*v.size());
			_finish = _start+ v.size();
			_endofstorage = _start + v.capicity();
		}
		
		//析构
		~vector()
		{
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}
		
		//获取数据个数
		size_t size() const
		{
			return _finish - _start;
		}
		
		//下标操作
		T& operator[](size_t pos)
		{
			assert(pos < size());

			return _start[pos];
		}

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

			return _start[pos];
		}
		
		//获取容量
		size_t capacity() const
		{
			return _endofstorage - _start;
		}
		
		//扩容
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				T* tmp = new T[n];
				size_t old_size = size();
				memcpy(tmp, _start, size() * sizeof(T));
				delete[] _start;

				_start = tmp;
				_finish = tmp + old_size;
				_endofstorage = tmp + n;
			}
		}
		
		//影响数据的扩容
		void resize(size_t n, const T& val = T())
		{
			if (n > size())
			{
				reserve(n);
				// 插入
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
			else
			{
				// 删除
				_finish = _start + n;
			}
		}
		
		//尾插
		void push_back(const T& val)
		{
			/*if (_finish == _endofstorage)
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2);
			}

			*_finish = val;
			++_finish;*/

			insert(end(), val);
		}
		
		//尾删
		void pop_back()
		{
			/*assert(!empty());

			--_finish;*/

			erase(--end());
		}
		
		//判空
		bool empty()
		{
			return _start == _finish;
		}
		
		//插入
		void insert(iterator pos, const T& val)
		{
			assert(pos >= _start);
			assert(pos <= _finish);

			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : capacity() * 2);

				// 如果扩容了要更新pos
				pos = _start + len;
			}

			iterator it = _finish - 1;
			while (it >= pos)
			{
				*(it + 1) = *it;
				--it;
			}
			*pos = val;
			++_finish;
		}
		
		//删除
		void erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);

			iterator it = pos + 1;
			while (it < _finish)
			{
				*(it - 1) = *it;
				++it;
			}

			--_finish;
		}

	private:
		iterator _start = nullptr;//指向起始位置
		iterator _finish = nullptr;//指向数据中的最后一个的下一个
		iterator _endofstorage = nullptr;//指向整个空间末尾的最后一个
	};

三、迭代器失效

1、原理：

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如:vector的选代器就是原生态指针T*。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃。

2、可能引起迭代器失效的操作

（1）引起底层空间的改变：resize、reserve、insert

上述接口都会引发扩容操作，当发生扩容时底层一般是开辟新空间，将该对象的数据拷贝给新空间，再释放该对象指向的旧空间，将该对象指向新的空间。下面以insert为例子进行详细讲解

为什么要保存pos到_start的距离呢？
这是因为发生扩容后_start指向了新的位置，而pos还是指向原来空间的位置，因此在开辟空间后需要将Pos的位置进行更新

（2）删除指定位置元素：erase

erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是:如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效