vector迭代器失效问题详解

导致迭代器失效主要有下面这两种情况：

• 迭代器的底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被释放了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)。这种就是野指针式失效。
• 迭代器代码层面的意义和实际意义不一致。

我们接下来对这两种失效情况进行分析。

resize、reserve、insert、assign、push_back这些可能会扩容的操作会导致迭代器指向一片已经被释放的空间，从而引发迭代器野指针式失效。

#include
#include 
using namespace std;
#include 
int main()
{
	vector<int> v{ 1,2,3,4,5,6 };
	auto it = v.begin();
	// 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
	// v.resize(100, 8);
	// reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
	// v.reserve(100);
	// 插入元素期间，可能会引起扩容
	// v.insert(v.begin(), 0);
	// v.push_back(8);
	// 给vector重新赋值，可能会引起底层容量改变
	v.assign(100, 8);
	
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	return 0;
}

这段代码编译器会报错，以上操作，都有可能会导致vector扩容，也就是说vector底层旧空间被释放掉，而在打印时，it指向的还是释放之前的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的空间，所以会引起代码运行时崩溃。

解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新赋值，更新下迭代器，让它指向新的空间即可。

//我们可以事先获取迭代器相对于起始处的位置
size_t n = it - v.begin();
//然后再扩容后，让迭代器指向新空间相应的位置
it = v.begin() + n;
//然后就可以继续利用迭代器对新空间进行操作了

添加或者删除元素会导致迭代器代码层面的意义和其实际意义不一致，进而导致迭代器失效。

int main()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.push_back(6);

	auto pos = find(v.begin(), v.end(),3);

	v.insert(pos, 30);
	
	for (auto e : v)
	{
		cout << e << " ";
	}

	v.erase(pos);

	for (auto e : v)
	{
		cout << e << " ";
	}
}

该段代码运行会报错，因为我们使用了失效的迭代器。

我们通过find函数的返回值，让迭代器指向3的位置，然后在该位置插入30，此时迭代器实际已经指向30了，而这个迭代器由于在代码层面上没有做出任何改变，因此代码层面还是指向3，此时迭代器代码层面的意义和其实际意义就不一致，我们在实际写代码的过程中，很有可能会忽略它的实际意义，而使用它错误的代码层面的意义，编译器无法确定我们是使用它的实际意义还是使用它错误的代码层面的意义，比如上面代码v.erase(pos);，编译器不知道我们到底是使用它的实际意义删除30，还是使用它错误的代码层面的意义删除3，编译器也就不好做处理，因此只要迭代器代码层面的意义和实际意义不一致，迭代器就会失效，如果我们在代码中继续使用该失效的迭代器，编译器就不知道我们使用的到底是迭代器的哪种意义，就会报错，崩溃。

比如下面这段代码，删除容器中的偶数：

#define _CRT_SECURE_NO_WARNINGS 1
#include 
using namespace std;
#include 


int main()
{
	vector<int> v{ 1, 2, 3, 4 };
	auto it = v.begin();
	while (it != v.end())
	{
	//如果迭代器所指向的元素是偶数，那么就删除该元素，然后迭代器+1指向下一个元素进行判断
		if (*it % 2 == 0)
			v.erase(it);
		++it;
	}

	return 0;
}

假设此时迭代器指向2，if语句判断是偶数，删除，然后迭代器+1指向下一个元素，进行下一个元素3的判断，看到这，如果你还没有发现出问题，你就已经落入迭代器失效的陷阱了。因为删除迭代器所指向的元素2后，迭代器就实际就已经指向3了，你再加1，迭代器实际指向的就是4了，那么3这个元素你就漏判了。写出这种错误代码的原因在于你误以为删除迭代器所指向的元素2后，迭代器仍然指向2，你仍然把迭代器当作指向2使用（使用了错误的代码层面的意义），所以你觉得再让迭代器加1指向下一个元素3刚刚好，实际上你删除了2后，迭代器就指向3了，你再加1，迭代器就指向4导致3漏判，这就是迭代器代码层面意义和实际意义不一致，迭代器失效，然后你又使用了错误的代码层面意义。

而此时编译器只知道你使用了代码层面意义和实际意义不一致的迭代器，即失效的迭代器，它不知道你是按错误的代码层面意义使用的迭代器，还是按照实际意义使用的迭代器，所以运行直接崩溃。

改进后的代码如下，我们在代码层面将迭代器更新一下，让迭代器代码层面的意义和它实际意义统一起来，从而避免失效的迭代器出现，也就没有所谓的两种意义，我们就不会使用错误的代码层面的意义，编译器也不会因为不知道我们使用的是哪种意义而运行崩溃。

int main()
{
	vector<int> v{ 1, 2, 3, 4 };
	auto it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
			it = v.erase(it);
		else
			++it;
	}
	return 0;
}

注意：Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端

还要注意与vector类似，string在出现上述两种情况（发生扩容和迭代器的意义发生变化），string的迭代器也会失效

#include 
void TestString()
{
	string s("hello");
	auto it = s.begin();
	// 放开之后代码会崩溃，因为resize到20会string会进行扩容
	// 扩容之后，it指向之前旧空间已经被释放了，该迭代器就失效了
	// 后序打印时，再访问it指向的空间程序就会崩溃
	//s.resize(20, '!');
	while (it != s.end())
	{
		cout << *it;
		++it;
	}
	cout << endl;
	
	it = s.begin();
	while (it != s.end())
	{
		it = s.erase(it);
		// 按照下面方式写，运行时程序会崩溃，因为erase(it)之后
		// it位置的迭代器就失效了
		// s.erase(it);
		//++it;
	}
}

迭代器失效解决办法：在使用前，对迭代器重新赋值，更新下迭代器即可。