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

一、list 迭代器失效问题

此处可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

        下面我用代码+调试录屏演示一下：       

void Testlist()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);


	auto pos = find(lt.begin(), lt.end(), 4);
	if (pos != lt.end())
	{
        // lt.erase(pos);
		pos = lt.erase(pos);

		*pos *= 100;
	}
}

int main()
{
	Testlist();

	return 0;
}

上面的代码演示可以看出来， pos 位置被 erase 之后 pos 就指向随机值了，pos 位置就失效了，如果再访问 pos 位置的话，程序就崩了。

那么怎么解决呢？

看文档！！！去看一下库里面的 erase 是怎么实现的，如下：

 

库里面的 erase 是有返回值的，那么返回值是返回的什么？继续看文档，如下： 

 文档大概意思就是说，返回被删除位置的下一个迭代器。

那么加上返回值的 erase 怎么样？如下：

如上图，接收了返回值之后，pos 返回的是 5 的位置，这也就是被删的下一个，这就解决了迭代器失效的问题。

 二、vector 迭代器失效问题

        对于vector可能会导致其迭代器失效的操作有：

        1. 会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、push_back等。

#include <iostream>
using namespace std;
#include <vector>
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);
 
 /*
 出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，
而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的
空间，而引起代码运行时崩溃。
 解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新
赋值即可。
 */
 while(it != v.end())
 {
 cout<< *it << " " ;
 ++it;
 }
 cout<<endl;
 return 0;
}

2. 指定位置元素的删除操作--erase

#include <iostream>
using namespace std;
#include <vector>
int main()
{
 int a[] = { 1, 2, 3, 4 };
 vector<int> v(a, a + sizeof(a) / sizeof(int));
 // 使用find查找3所在位置的iterator
 vector<int>::iterator pos = find(v.begin(), v.end(), 3);
 // 删除pos位置的数据，导致pos迭代器失效。
 v.erase(pos);
 cout << *pos << endl; // 此处会导致非法访问
 return 0;
}

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

下面代码删除偶数为什么有不一样的结果？

1. 第一种：正常运行。

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

	auto it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			v.erase(it);
		}

		++it;
	}

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

 2. 第二种：崩溃

	void test_vector()
	{

		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);

		auto it = v.begin();
		while (it != v.end())
		{
			if (*it % 2 == 0)
			{
				v.erase(it);
			}
			++it;
		}

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

3. 第三种：结果不对。

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

	auto it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			v.erase(it);
		}
				
		++it;
	}

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

上面是为什么呢？可以尝试自己分析一下。（我用的VS2019，linux下和VS下对迭代器的检查也是有区别的）

下面是正确的代码，接收返回值就解决了。

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

	auto it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			it = v.erase(it);
		}
		else
		{
			++it;

		}
	}

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

string的话，在插入扩容删除之后，也会迭代器失效。 

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