8.【CPP】Vector（扩容问题||迭代器失效问题&&简述迭代器的种类）

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

一.常用接口介绍

官方文档

1.resize和reserve

区别

1.resize开空间并且初始化，reserve只负责开空间。意味着reserve后不能通过下标访问元素，因为它只开了容量空间，而resize后改变了容器大小并初始化了容器对象可以通过下标访问元素。
2.reserve只接受一个参数表示预留空间的大小，resize接受两个参数，一个是空间大小，第二个是填充空间的对象类型如果没有就调用对象的默认构造函数。
3.如果resize的大小比当前capacity大，那么vector中存储元素的地址会发生改变(vector对象的地址不变)，会引起内存中指针引用的重新分配。因此用resize扩容前可以用reserve预留足够的空间再初始化。

模拟实现

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 + sz;
				_end_of_storage = _start + n;
			}
		}

		void resize(size_t n, const T& val = T())
		{
			if (n > capacity())
			{
				reserve(n);
			}

			if (n > size())
			{
				while (_finish < _start + n)
				{
					*finish = val;
					++finish;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

2.oprerator【】和at（）

前者会用断言检查越界 ，后者则会抛异常。

二.知识点总结

1.构造函数

vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{}

		vector(const vector<T>& v)
		{
			_start = new T[v.capacity()];//v.size()也可以
			memcpy(_start, v._start, sizeof(T) * v.size());
			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();
		}

		vector(size_t n, const T& value = T())
			:_start(new T(n))
			, _finish(_start + n)
			, _end_of_storage(_finish)
		{
			for (int i = 0; i < n; i++)
			{
				_start[i] = value;
			}
		}

		vector(int n, const T& value = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(n);
			while (n--)
			{
				push_back(value);
			}
		}

		template<class InputIterator>//写成模板可以用其他类型的迭代区间构造
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

2.赋值运算符重载

		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_end_of_storage, v._end_of_storage);
		}
	//赋值v1=v2,适用于所有的类深拷贝
		vector<T> operator=(const vector<T>& v)
		{
			swap(v);
			return *this;
		}

3.迭代器失效问题

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

#include
#include

using namespace std;

int main()
{
	vector<int> v = { 1,2,3,5,7 };

	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 1)
			v.erase(it);
		it++;
	}

	return 0;

}

在进行删除时由于把当前位置数据删了，后面的数据要分别向前移动一个位置，因此删除该位置后的迭代器全部失效。

解决方案

#include

using namespace std;

int main()
{
	vector<int> v = { 1,2,3,5,7 };

	vector<int>::iterator it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 1)
			it = v.erase(it);
		else
			it++;
	}
	return 0;

}

erase后返回删除位置下一个位置迭代器，用it再去接收即可。

同理解决插入问题

如果每次插入之后不更新迭代器，那么insert时如果发生扩容，那么迭代器指针就会指向新开的空间而此时的it仍指向旧空间，向后访问就会出现野指针的问题了。
因此仍然需要每次插入过后更新it迭代器

4.简述迭代器按功能分类问题

单向迭代器：++ eg：forward_list,unordered_map
双向迭代器：++ ，-- eg:list
随机迭代器：++，–，+，- eg:vector