c++ STL 迭代器失效问题
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了c++ STL 迭代器失效问题相关的知识，希望对你有一定的参考价值。
请教大家一个问题 在对容器元素进行添加和删除时，iterator会部分或全部的失效。下面一个例子
vector<int>::iterator first=v.begin(),last=v.end();
while(first!=last)
//do some processing
//insert new value and reassign first,which otherwise would be invalid
first=v.insert(first,42);
++first;
上述代码的行为未定义，原因是循环体中实现了元素的添加运算，添加元素使得存储在last中的迭代器失效。该迭代器既没有指向容器的v元素，也不再指向v的超出末端的下一个位置。
问题1：为什么“该迭代器既没有指向容器的v元素，也不再指向v的超出末端的下一个位置”。迭代器不是一个指针吗？虽然删除了他指向的元素，但在他所指向的地址又添加了其他元素，为什么会不指向容器中的元素呢？
问题2：对于vector类型的容器，当在其中（非末端下一个位置）插入元素时，是不是插入点以后的所有元素都向后移动？
1) 无法通过迭代器++,--操作遍历整个stl容器。记作: 第一层失效。
2) 无法通过迭代器存取迭代器所指向的内存。 记作: 第二层失效。
关于这个问题, 不同的容器对应的结果是不同的。
vector
vector是个连续内存存储的容器，如果vector容器的中间某个元素被删除或从中间插入一个元素， 有可能导致内存空间不够用而重新分配一块大的内存。
这个动作将导致先前获取的迭代器,，第一层和第二层均失效。
map
map内部是红黑树结构，当map中新插入或删除元素后，树的结构会相应的调整。
但是，通过先前的迭代器，仍然可以通过++可以遍历map。 能遍历到值>当前迭代器的节点。 (没有看具体stl内部实现,初步代码验证正确)
迭代器指向的用户数据内存始终有效。
list
同理map, 通过++只能遍历链表右侧的节点，迭代器指向的用户数据内存也始终有效。 参考技术A
你可以把迭代器理解为，用对象封装的指针（实际上并不是一定这样，但是你可以这么去理解）。
迭代器失效是因为，某一些容器在进行一些操作的时候，会因为各种原因（比如之前分配的内存不够啊等等）申请新的内存地址，并把数据转移过去，老的内存有可能会被释放。
迭代器就好比门牌号一样，你现在在一栋楼里，挨个门访问。
突然，楼里面的居民全部搬家了，这时候你还去访问以前的那个门牌号，那肯定你是找不到人的。
这个时候，你需要想办法拿到新的地址，这样你可以接着访问。
调用任何vector的non const函数都有可能使之前获得的迭代器失效。例如push back，insert，erase等等。
至于在容量足够的情况下，添加元素必然会使从添加位置起的所有迭代器失效（因为数据被移动了）。
要处理这种情况也很简单，就是在每一次有可能使迭代器失效的操作进行之后，重新取迭代器。
也就是，在insert后面加一行 last = v。end（）
while (first != last)//do some processing
//insert new value and reassign first,which otherwise would be invalid
first = v.insert(first, 42);
++first;
++first;
last = v.end();
参考技术B 问题一：先看一段话
在创建一个vector 后，它会自动在内存中分配一块连续的内存空间进行数据存储，初始的空间大小可以预先指定也可以由vector 默认指定，这个大小即capacity （）函数的返回值。当存储的数据超过分配的空间时vector 会重新分配一块内存块，但这样的分配是很耗时的，在重新分配空间时它会做这样的动作：
首先，vector 会申请一块更大的内存块；
然后，将原来的数据拷贝到新的内存块中；
其次，销毁掉原内存块中的对象（调用对象的析构函数）；
最后，将原来的内存空间释放掉。
可以发现，如果你插入的值使得vector的预先分配容量不够用时，vector将会重新申请一块内存，那么原来的内存就无效了，虽然存在原来的地址还在使用并且添加了其他元素，但是这是不安全的，因为你不知道什么时候重新申请了新内存。所以vector不允许这样做。
问题2：
是的，因为vector是连续存储，这也是问题一的原因追问
如果添加一个元素时内存够用，不需要重新分配 ,将元素向后移 迭代器原先所指向的地址不是又添加了其他元素
这时迭代器为什么也会失效呢
当不需要重新分配时，迭代器原先所指向的地址确实变成了其他元素，这个我已经验证过了。说它失效是因为我们不知道什么时候vector会重新申请内存，我们不能做没有把握的事。即使vector没有重新分配内存，迭代器所指向的内容也不是我们所需要的了，对它做操作没有意义。你也不要纠结于“失效”这两个字，当迭代器的行为不可预知时，我们就认为它是失效的。
本回答被提问者和网友采纳 参考技术C 你这个是一个死循环。C++初阶：STL —— vectorvector的介绍及使用 | 迭代器失效问题 | vector的深度剖析及模拟实现
文章目录
【写在前面】
相比于 string，vector 的使用更加容易上手的，且它的接口比 string 要少上许多，再加上我们已经学过类似的 string，并且在数据结构篇的顺序表就已经触及过了。vector 在实际中也非常的重要，在实际中我们熟悉常见的接口就可以了。
在 vector 开始我们就可以尝试着去瞅一瞅 STL 的源码了，string 为什么没看的原因，在之前也说过，对于 string 是在 STL 这个规范前被设计出来的。我们的瞅的源码主要参考 P.J 版本和 SGI 版本。
怎么看 ❓
-
P.J
对如下代码打断点后调试，单步执行就可以查阅了
Visual Studio 2017 参考如下目录：
但是对于 P.J 版本的有些地方还涉及了 C++11 的优化，可能会看不懂，所以我们主要参考 SGI 版本。 -
SGI
这里有一本书《STL源码剖析》，它用的是 STL3.0 的版本，有需要的同学可私信电子版本。当然这本上核心的内容我们都会学习。
stl3.0 一览 ❓
-
解包后，找到 vector 并打开
-
找到 stl_vector.h 并打开(核心代码也就 500 多行)
-
怎么阅读
众所周知，看别人的代码是一件很痛苦的事情，如果他的水平高于你，那么你是能成长的，但是看的过程中不要一行一行的去看，这样会导致你只见树木不见森林。这里记住 “二八原则”，一个 1000 行的代码，只有 200 行是最核心的，只要把这 200 行看懂了，那么就都懂了。
-
核心代码简单筛选如下
需要查阅的文件：vector ➡ stl_vector.h ➡ stl_construct.h
💨vector
#include <stl_algobase.h>
#include <stl_alloc.h>
#include <stl_construct.h>
#include <stl_uninitialized.h>
#include <stl_vector.h>
#include <stl_bvector.h>
💨stl_vector.h
//这里的模板给的是缺省参数,也就意味着不传也行。Alloc是空间配置器,是一个内存池去申请和释放空间,我们直接用new也行,只不过内存池的效率要高一点
template <class T, class Alloc = alloc>
class vector
public:
typedef T value_type;
typedef value_type* iterator;
protected:
//这里为啥没有看到指针、size、capacity之类的东西? ———— 我们可以先看下iterator是啥(在public里已经指明了)
//所以这里就给了三个T*的指针
iterator start;
iterator finish;
iterator end_of_storage;
public:
//其次还可以去看下它的构造函数,它完成了对3个成员变量的初始化工作
vector() : start(0), finish(0), end_of_storage(0)
//其次再看下push_back的实现
//现阶段我们看源码还是有些难度的,等到后期我们会深挖
void push_back(const T& x)
//说明没满
if (finish != end_of_storage)
//这里不是直接赋值,而是调用construct,原因这里要对一块已有的空间显示调用构造函数初始化,我们在stl_vector.h里并没有找到有关实现
//其实这里就要结合vector来看了,上面我们不是有一堆头文件嘛,那么它的实现肯定就在stl_vector.h上面的头文件中————stl_construct.h
construct(finish, x);//怎么实现的?
++finish;
//满了,增容
else
insert_aux(end(), x);//怎么实现的?
💨stl_construct.h
//construct是一个函数模板2
template <class T1, class T2>
inline void construct(T1* p, const T2& value)
new (p) T1(value);//定位new表达式
📝补充
对于顺序表而言，虽然它改名为 vector 了，但它的实现跟以前的了解的还是大同小异的。
一、vector的介绍及使用
💦 vector的介绍
- vector 是表示可变大小数组序列 容器
- 就像数组一样，vector 也采用的连续存储空间来存储元素。也就是意味着可以采用下标对 vector 的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理
- 本质讲，vector 使用动态分配数组来存储它的元素。当新元素插入的时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector 并不会每次都重新分配大小
- vector 分配空间策略：vector 会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数组增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的
- 因此，vector 占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长
- 与其它动态序列容器相比(deques，lists and forward_lists)， vector 在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起 lists 和 forward_lists 统一的迭代器和引用更好
💦 vector的使用
1、vector的定义
| (constructor)构造函数声明 | 接口说明 |
|---|---|
| ⭐vector() | 无参构造 |
| vector(size_type n, const value_type& val = value_type()) | 构造并初始化 n 个 val |
| ⭐vector(const vector& x) | 拷贝构造 |
| vector(InputIterator first, InputIterator last) | 使用迭代器进行初始化构造 |
📝说明
-
default(1)
这里给的是一个缺省值，现在这个阶段我们只要看到 alloc 就可以直接忽略它，它是 STL 六大组件中的空间配置器。 -
fill(2)
value_type 是第一个模板参数，它是一个 \\0
-
range(3)
这里的迭代器还是一个函数模板，也就是说这里的迭代器不一定是 vector 的迭代器
#include<iostream>
#include<vector>
#include<string>
using namespace std;
void test_vector1()
vector<int> v;
//在C实现数据结构中我们的代码风格是驼峰法，而STL整体的风格是小写和下划线分隔的风格
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
//遍历vector
//1、operator[]
for(size_t i = 0; i < v.size(); ++i)
v[i] -= 1;
cout << v[i] << " ";
cout << endl;
//2、迭代器
vector<int>::iterator it = v.begin();
while(it != v.end())
*it += 1;
cout << *it << " ";
++it;
cout << endl;
//3、范围for
for(auto& e : v)
++e;
cout << e << " ";
cout << endl;
//为什么有了vector,还要有string呢
//vector里给char，虽然它们底层都是数组中存储char,但是还是不一样的
//相比T是char的vector,s对象中指向的空间结尾有\\0,这样符合很多规范,比如需要去玩strstr、strcpy等,而vector不能玩+=字符串等
//所以说T是char的vector不能去替代string
string s("111111");
vector<char> vc(6, '1');
//可以使用一段迭代器区间去构造,也可以控制这一段区间,且这里属于深拷贝(所有自己有独立空间的都要深拷贝)
vector<int> v1(v.begin(), v.end());
vector<int> v2(++v.begin(), --v.end());
//可以使用其它容器的迭代器去构造,只要数据类型可以匹配上(*iterator对象的类型跟vector中存的数据类型是一致的)
string s1("hello world");
vector<char> v3(s1.begin(), s1.end());
//vector<char*> v3(s1.begin(), s1.end());//err,无法从char转换到char*
//怎么实现的
/*template<class InputIterator>
vector(InputIterator first, InputIterator last)
while(first != last)
push_back(*first);
++first;
*/
//拷贝构造
vector<int> v4(v);
int main()
test_vector1();
return 0;
📝补充
-
List item
这里我们发现一个问题，我们在用容器时，都不关心析构，因为出了作用域它自动调用，但是你得知道析构函数的价值。 -
List item
vecor 是没有设计写时拷贝的，string 有可能设计了，并且之前也说了在 STL 容器上，写时拷贝也是存在缺陷的，所以并不是特别主流，g++ 下有用过，但好像后面还是舍弃了(这里后面会验证)
2、vector iterator的使用
| 接口 | 说明 |
|---|---|
| ⭐begin+end | 获取第一个位置的 iterator/const_iterator，获取最后一个数据的下一个位置的 iterator/const_iterator |
| rbegin+rend | 获取最后一个数据位置的 reverse_iterator，获取第一个数据的前一个位置的 reverse_iterator |
#include<iostream>
#include<vector>
using namespace std;
void test_vector1()
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
//begin+end,这里和string非常相似，可以说迭代器就是指针
vector<int>::iterator it = v.begin();
while(it != v.end())
cout << *it << " ";
++it;
cout << endl;
//rbegin+rend,rbegin(rit)指向5,rend指向1,++rit怎么会倒着走呢
//这里rit其实不再是原生指针了,它是一个被封装的类对象,重载operator++,才能实现++rit时是反向走,具体细节后面会说明
//所以这就是之前为什么说迭代器不一定是(原生)指针的原因
vector<int>::reverse_iterator rit = v.rbegin();
while(rit != v.rend())
cout << *rit << " ";
++rit;
cout << endl;
int main()
test_vector1();
return 0;
📝补充
3、vector空间增长问题
| 容量空间 | 接口说明 |
|---|---|
| size | 获取数据个数 |
| capacity | 获取容量大小 |
| empty | 判断是否为空 |
| ⭐resize | 改变 vector 的 size |
| ⭐reserve | 改变 vector 放入 capacity |
#include<iostream>
#include<vector>
using namespace std;
void test_vector1()
vector<int> v;
//开空间,改变容量,如果确定知道需要多少空间,reserve可以缓解vector增容所带来的代价
v.reserve(10);
/* err,错误访问,在之前string里就说明了operator[]会去检查下标是否小于size,[]只能去对size范围内的数据使用
for(size_t i = 0; i < 10; ++i)
v[i] = i;
*/
//ok,正确访问
for(size_t i = 0; i < 10; ++i)
v.push_back(i);
//开空间+默认初始化,resize会影响size
v.resize(20);
//开空间+指定初始化
v.resize(20, 1);
int main()
test_vector1();
return 0;
📝补充
-
List item
operator[] 和 at 的区别 ❓
它们的功能类似，区别点在于：operator[] 检查越界比较粗暴，如果下标大于等于 size，它会直接断言报错，并中止程序；而 at 报错会抛异常，捕获后，它不会直接中止掉程序。
-
List item
在 string 里也说明过了。这里vector 的 capacity 的代码在 vs 和 g++ 下分别运行会发现：vs 下 capacity 是按 1.5 倍增长的，且这里的初始容量是 0；g++ 是按 2 倍增长的，且这里的初始容量也是 0。这个问题经常会考察，不要固化的认为，顺序表的增容都是 2 倍，具体增长多少是根据具体的需求定义的。vs 是 PJ 版本的 STL，g++ 是 SGI 版本的 STL.
4、vector增删查改
| vector 增删查改 | 接口说明 |
|---|---|
| ⭐push_back | 尾插 |
| ⭐pop_back | 尾删 |
| find | 查找(注意这个是算法模块的实现，不是 vector 的成员接口) |
| insert | 在 position 之前插入 val |
| erase | 删除 position 位置的数据 |
| swap | 交换两个 vector 的数据空间 |
| ⭐operator[] | 像数组一样访问 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
using namespace std;
void test_vector1()
std::vector<int> first;
std::vector<int> second;
std::vector<int> third;
//assign可以分配新内容，替换其当前内容，并相应地修改其size
//n个val
first.assign(7, 100);
//迭代器区间
std::vector<int>::iterator it;
it = first.begin() + 1;
second.assign(it, first.end() - 1);
//指针区间,这里myints指向1,myints+3指向4,为什么只输出1 2 3
//这里的两个参数myints,myints+3分别传给迭代器区间first,last。迭代器一定是一个左闭右开的区间[first, last),因为迭代器的循环条件是first!=last
int myints[] = 1, 2, 3, 4, 5 ;
third.assign(myints, myints + 3);
for(auto e : third)
std::cout << e << " ";
std::cout << "Size of first:" << int(first.size()) << '\\n';
std::cout << "Size of second:" << int(second.size()) << '\\n';
std::cout << "Size of third:" << int (third.size()) << '\\n';
void test_vector2()
int a[] = 1, 2, 3, 4, 5 ;
vector<int> v(a, a + 5);
//头插
v.insert(v.begin(), 0);
//在2的前面插入,可以先find 2,但是vector没有提供find,但是算法里提供了函数模板的find
//之所以算法里提供find的原因是vector要find,list要find,所以这里的find提供一个模板就解决了,你可以是vector的迭代器,也可以是list的迭代器,string的迭代器没必要,当然string里自己提供了,为什么string要自己提供呢
//因为string不仅要支持find一个字符,还要支持查找一个字符串,使用find要包algorithm
vector<int>::iterator pos = find(v.begin(), v.end(), 2);
if(pos != v.end())//找不到返回last
v.insert(pos, 20);
void test_vector3()
//讲了算法里的find后,顺道再讲一下比较常用的sort
int a[] = 1, 20, 2, 3, 4, 5 ;
vector<int> v(a, a + 6);
//升序
sort(v.begin(), v.end());
//降序,这里需要传一个比较器对象,这里就涉及仿函数,具体在后面优先级队列会详细介绍,使用它需要包functional
/*greater<int> gt;
sort(v.begin(), v.end(), gt);*/
sort(v.begin(), v.end(), greater<int>());//同上,更推荐使用匿名对象
//sort不仅可以对容器排序,还可以对数组排序,因为指向数组空间的指针是天然的迭代器
//也就是说从现在开始就可以把C语言的qsort放弃了
int b[] = 30, 4, 50, 6, 7 ;
sort(b, b + 5);
void test_vector4()
int a[] = 1, 20, 2, 3, 4, 5 ;
vector(int> v(a, a + 6);
//头删
v.erase(v.begin());
//删除2
vector<int>::iterator pos = find(v.begin, v.end(), 2);
if(pos != v.end))
v.erase(pos);
int main()
test_vector1();
test_vector2();
test_vector3();
test_vector4();
return 0;
📝说明
-
List item
-
List item
-
List item
operator[] 和 at 的区别 ❓
它们的功能类似，区别点在于：operator[] 检查越界比较粗暴，如果下标大于等于 size，它会直接断言报错；而 at 报错会抛异常，捕获后，它不会直接中止掉程序。
5、vector迭代器失效问题(建议与vector的模拟实现一起分析)
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector 的迭代器就是原生态指针 T*。因此迭代器失效，实际就是迭代器底层对应指针所指向的空间被销毁了(迭代器失效问题就类似于野指针问题)，而使用一块已经被释放的空间，造成的后果就是程序崩溃(即如果继续使用已经失效的迭代器，程序可能会崩溃)
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void test_vector1()
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4):
vector<int>::iterator pos = find(v.begin(), v.end(), 以上是关于c++ STL 迭代器失效问题的主要内容，如果未能解决你的问题，请参考以下文章
C++初阶：STL —— vectorvector的介绍及使用 | 迭代器失效问题 | vector的深度剖析及模拟实现
C++初阶：STL —— vectorvector的介绍及使用 | 迭代器失效问题 | vector的深度剖析及模拟实现