C++STL【vector】常用接口函数使用和迭代器失效问题

在上一篇博客中我们对string类有了基础的了解,这里建议大家先对string有一定的了解再去学习vector,它们有很多相似之处:C++STL【string】常用接口函数以及模拟实现-CSDN博客。在本篇的学习中还是建议大家对照着C++文档来进行学习:vector - C++ Reference

一.vector的介绍

std::vector 是 C++ STL 中的动态数组模板。它底层是一块连续的内存(类似 C 语言的顺序表),支持自由存储任意类型的数据。其支持"全自动内存管理"(自动扩容、自动释放),无需像 C 语言那样手动 malloc/free。

在开始之前,因为各个容器的接口函数有很大的共通性,我们对vector的函数不会像string那样仔细讲解,大部分就只会说一下功能和用法,这里的重点还是迭代器失效。

二.vector的默认成员函数

1.构造函数

构造函数的各个重载:vector::vector - C++ Reference

需要说明的是:在这里有一个参数:const allocator_type& alloc = allocator_type();这是个内存池,在这里我们不用在意,要我们自己传的情况很少,另外它也给了缺省值,所以可以不看这个参数。在这里我就直接把这个参数给去掉了,更方便学习

cpp 复制代码
default (1)	
explicit vector ();
fill (2)	
explicit vector (size_type n, const value_type& val = value_type());
range (3)	
template <class InputIterator>
vector (InputIterator first, InputIterator last);
copy (4)	
vector (const vector& x);
C++11中的列表初始化(5)
vector (initializer_list<value_type> il);

①默认的无参构造

②用n个value_type(也就是你实例化时给的类型,你给int它就是int,你给string他就是string)类型的值去构造,后面等于的"value_type()"是一个调用这个类型的默认构造函数创建出来的匿名临时对象。int() 就是 0,string() 就是空字符串。是的,C++中内置类型也有默认构造了,其实是为了迎合模板,就像现在这样可以内置类型和自定义类型写在一块了。

③使用一段迭代器区间去构造

④拷贝构造

⑤比较常用,允许使用{}去初始化各个值

使用实例:

cpp 复制代码
void Test1()
{
	//默认构造
	vector<int> v1;
	//使用第一个参数数量的第二个参数去初始化
	vector<int> v2(6,8);
    //第二种用法,直接不写第二个参数,就相当于开对应个数的空间
    vector<int> v(6);
	//拷贝构造
	vector<int> v3(v2);
	//使用迭代器区间构造
	vector<int> v4(v2.begin() + 2, --v2.end());
	//C++11引入链表初始化
	vector<int> v5{ 1,2,3,4,5 };
}

2.析构函数

vector的对象生命周期结束时自动调用去释放空间

cpp 复制代码
~vector();

3.operator=(赋值运算符重载)

把一个已经实例化的vector对象赋值给另一个vector对象

cpp 复制代码
vector& operator= (const vector& x)

三.迭代器相关函数

还是这几个函数,其功能和行为都和string的一模一样

• begin返回指向第一个数据的迭代器,end()返回最后一个数据的下一个位置的迭代器

• rbegin()返回的是最后一个元素位置的迭代器,rend()返回的是第一个位置的前一个位置的迭代器。

• 范围for这些也都是照常支持的,因为vector和string的底部迭代器一样所以范围for的行为和用法也相同

四.vector的大小和容量操作函数

1.size,max_size,capacity,empty

• size():返回对象有多少个元素。

cpp 复制代码
size_type size() const;

• max_size():返回理论上最多能存多少元素。

cpp 复制代码
size_type max_size() const;

• capacity():返回现在对象的容量是多少。

cpp 复制代码
size_type capacity() const;

• empty():判断对象是否为空,空返回1,非空返回0。

cpp 复制代码
bool empty() const;

注意:这里的size_type返回值其实就是size_t,这个在vector内部给typedef了一下

2.reserve,resize

①reserve:功能:和string的一样,提前预分配好内存,把 capacity 扩大到至少 n,但不改变 size,也不创建任何元素。

cpp 复制代码
void reserve (size_type n);

②resize:这个函数的本质和string的resize一样,但是因为vector是模板,里面可能存储自定义类型的缘故,还是有些地方不同的。

cpp 复制代码
void resize (size_type n, value_type val = value_type());

情况一:n>size,如果n也大于capacity那就会扩容,不大于capacity就不扩,然后用你给的值(或者对应类型的默认构造出的匿名对象的值)去填充扩大部分的size。

情况二:n<size,capacity不变,会直接把size变成你给的n的大小,然后会销毁尾部多出来的元素,如果是类类型还会调用析构函数。

五.元素访问函数

• 这里operator\[\]和at的行为和string的一模一样,都是可以通过下标像数组一样去访问容器内部的数据。

• front就是访问v0(第一个元素),back就是访问vv.size() - 1(最后一个元素)

六.内容修改函数

1.push_back,pop_back

• push_back为尾插,在尾部插入一个元素。pop_back为尾删,删除尾部元素。

2.insert,erase

• insert: vector::insert - C++ Reference在指定位置插入数据

• erase: vector::erase - C++ Reference删除一个指定位置或者一个迭代器区间

注意:这里要稍微留心一下二者的返回值,它们的返回值都为iterator,这里在后续的迭代器失效部分有奇效。

3.swap,assign,clear

• swap:和string一样有一个在vector内部的swap和一个在std全局的swap,两者都是用来交换vector的对象的只是写法不同

cpp 复制代码
//std::vector::swap
void swap (vector& x);
//std::swap
template <class T, class Alloc>
void swap (vector<T,Alloc>& x, vector<T,Alloc>& y);
cpp 复制代码
void test2()
{
	vector<int> v1{ 1,2,3,4 };
	vector<int> v2{ 5,6,7,8 };
	v1.swap(v2);
	swap(v1, v2);
}

•assign:替换容器内容,就是"清空重置",它会丢掉容器里原有的所有内容,用新数据完全覆盖,并且会根据新数据的数量改变容器大小(会创建新元素),绝不是只改前几个值。

•clear:删除容器内的所有值,把size设置为空,但是capacity不变,保持原大小

七.非成员函数

• 就是关系运算符和上面说到的全局的swap

八.vector的迭代器失效

1.什么是迭代器失效

• vector的迭代器iterator在底层就是原生指针T*,导致迭代器失效的原因主要有两种:

①底层空间经历了重新分配(扩容):此时旧空间被释放,原来的迭代器还是指向被释放的旧空间,导致其变成野指针,再次使用会导致程序崩溃。

②元素发生移动(插入/删除):此时的空间虽然没被释放,但是插入/删除的位置后面的元素发生了整体移动。原来的迭代器可能没有变成野指针,但指向的数据发生了改变,或者超出的当前的有效范围(越界),继续按照之前的逻辑使用会导致逻辑错误或程序崩溃。

2.会导致迭代器失效的三大场景

场景1:会引起底层空间改变(扩容)的操作,都用可能引起迭代器失效

如:resize,reserve,insert,push_back,assign等

失效原因:当vector容量不足时,会开辟一块更大的新内存,把旧数据拷贝过去,并释放旧内存。此时之前保存的迭代器依然指向被释放的旧内存,变成了野指针。不仅是指向特定元素的迭代器,你所有的旧迭代器(包括在发生扩容之前获取的begin()和end())也都会失效。(这里不是说begin和end函数失效了,说的是之前调用begin返回的那块内存,函数本身不会出错)

错误使用方式:

cpp 复制代码
int main()
{
	vector<int> v1{ 1,2,3 };
	//这里来一个旧空间的begin()
	auto it = v1.begin();
	//通过resize把有效数据增加到20个,操作期间底层会扩容
	v1.resize(20, 8);
	//reserve的作用就是扩容,操作期间会导致底层内存的改变
	v1. reserve(50);
	//插入元素可能引起扩容,导致旧空间被释放
	v1.insert(v1.begin(), 9);
	v1.push_back(10);
	//给vector重新赋值,可能引起底层容量改变
	v1.assign(150, 8);

	//旧空间被释放,这里是野指针,直接报错
	*it = 10;

	return 0;
}

解决办法:不要在以上可能触发扩容的操作面前保存之前的迭代器。操作完成后如果还想使用迭代器操作函数或访问元素必须重新获取迭代器。

正确使用方式:

cpp 复制代码
int main()
{
	vector<int> v{ 1,2,3,4,5 };
	auto it = v.begin();
	//扩容操作
	v.reserve(50);
	//操作完成后及时更新迭代器
	it = v.begin();
	*it = 10;
	return 0;
}

场景2:insert插入导致的迭代器失效(场景1中对insert的特殊说明,还有未扩容情况)

失效原因:即使没有触发扩容,因为insert是在中间插入,为了保证vector连续储存的结构,pos位置之后所有元素都整体向后移动了。此时pos迭代器指向的内容发生了改变,继续使用pos迭代器会发生逻辑错误。

错误使用方式:

这里在debug下还会因为错误使用被强制拦截。

解决办法:insert函数是有返回值的,这里在上面也让各位留心了一下,它会返回指向新插入元素的有效迭代器,记得接收它。在这里分为两种情况:①是insert导致了扩容,那原来的it失效,insert的返回值是新空间的有效值。②未导致扩容,insert的返回值就等于it,但是为了代码的健壮性和全面的一致性,仍然要接收返回值。毕竟你也不知道啥时候扩容,接收返回值既能提醒大家it指向的到底是谁,也能让大家使用的时候养成良好的习惯。

正确使用方式:

cpp 复制代码
int main()
{
	vector<int> v1{ 1,2,3,4,5,6 };
	//让it指向3
	auto it = v1.begin() + 2;
	//在3前插入99,并接收insert的返回值
	it= v1.insert(it, 99);
	//此时it指向刚插入的99,也能提醒我们去变化it的值
	++it;
	//现在成功吧3改成了88
	*it = 88;
	return 0;
}

场景3:erase删除导致的迭代器失效(最经典的坑)

失效原因:erase删除pos位置,回导致pos位置后面的元素整体前移,所以pos及其之后的迭代器全部失效。

错误使用方式(也是一个超级经典的题):

cpp 复制代码
int main()
{
	vector<int> v1{ 1,2,3,4,5,6,7,8};
	//现在我要删除全部的偶数
	auto it = v1.begin();
	while (it != v1.end())
	{
		if (*it % 2 == 0)
		{
			v1.erase(it);
		}
		it++;
	}
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << ' ';
	}
	return 0;
}

这样写可能根据数据的不同会出现能过编译但是不对,过了而且对了,直接报错这三种情况,原因就在于erase之后的迭代器失效。

解决办法:

erase 同样有返回值,它返回的是被删除元素的下一个有效迭代器。

为什么?因为删除元素后,为了保持内存连续,后面的所有元素会整体向前覆盖。此时,原来的 it 所在的位置,虽然物理地址没变,但它里面的数据已经被后面的元素顶替了。所以 erase 把这块"原地址"重新包装成一个有效的迭代器返回给你。

为什么一定要用 it 接收返回值?

因为 C++ 标准规定,一旦执行了 erase,原本传入的那个 it 就已经"失效"了。虽然在有些情况下(比如不触发内存重分配),它底层的地址数值没变,但在语法和标准层面,它已经失去了作为一个迭代器的"合法身份"。 如果不接收返回值,你继续用旧的 it,在 Debug 模式下(如 MSVC),标准库会直接触发断言拦截你(报错 invalidated iterator);而在 Release 模式下,编译器虽然不会拦截,但这属于未定义行为,极易引发隐蔽的 Bug。

所以,我们绝对不能在 erase 之后对原 it 直接 ++! 因为容器内部已经进行了一次前移,此时原地址上已经是下一个元素了。再 ++ 就会跳过当前元素。而正确的做法是:接收 erase 返回的新迭代器(拿到合法身份),如果你需要继续遍历,直接拿这个新迭代器操作即可,不需要也不允许再 ++。

正确使用方式:

cpp 复制代码
int main()
{
	vector<int> v1{ 1,2,3,4,5,6,7,8};
	//现在我要删除全部的偶数
	auto it = v1.begin();
	while (it != v1.end())
	{
		if (*it % 2 == 0)
		{
			it = v1.erase(it);
		}
		else
		{
			it++;
		}
	}
	return 0;
}

3.string的迭代器失效

string 底层同样是连续字符数组,迭代器也是原生指针。前面讲过的三大失效场景在 string 中同样适用,但是只有一个差别需要注意:

insert 插入导致的失效(核心差异点) 失效原因:中间插入导致后面元素整体后移,原迭代器逻辑失效。 与 vector 的重大区别:vector::insert 返回的是新元素的迭代器;但 string::insert 返回的是 string&(当前对象自身的引用)!解决办法:string 无法通过接收返回值来更新迭代器。如果插入后还要操作原位置,必须重新计算(记录相对下标)或重新获取。

相关推荐
Eider19981 小时前
Python基础语法之并发相关3
开发语言·python
FRing031 小时前
vue2干货总结11(短信验证、登录功能、统一处理错误(响应拦截器)、将token信息存入vuex、vuex持久化处理)
开发语言·前端·javascript·vue.js·vue2
CS_Zero2 小时前
DeepSeek V4.1 Flash 1017 (Batch) 新手极速上手指南
开发语言·batch·deepseek
山楂树の2 小时前
Java 字符串高效处理:StringBuilder、StringBuffer、StringJoiner
java·开发语言
Risehuxyc2 小时前
C# 发展历史
开发语言·c#
HaiXCoder3 小时前
C++ 表达式怎么读:从一行代码到类型、值类别和生命周期
c++
七夜zippoe3 小时前
Nexent 知识库:调优靠 Chunk 与重排
开发语言·python·ai智能体·nexent·知识库与rag
kyle~4 小时前
C# --- 反射
开发语言·c#
soso19685 小时前
低功耗设计与BMS开发指南
c语言·开发语言·汇编