vector迭代器失效与深浅拷贝问题

最新推荐文章于 2023-07-18 20:49:26 发布

Fan~Fan

最新推荐文章于 2023-07-18 20:49:26 发布

阅读量311

点赞数 1

分类专栏：《彻悟C++》文章标签： c++ 开发语言算法 stl

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/weixin_60718941/article/details/128346957

版权

《彻悟C++》专栏收录该内容

17 篇文章 4 订阅

订阅专栏

目录

1、vector迭代器失效问题

1.1、insert迭代器失效

扩容导致野指针

官方库windows下VS和linux下对insert迭代器失效的处理

1.2、erase迭代器失效

官方库windows下VS和linux下对erase迭代器失效的处理

1.3、迭代器失效总结

2、深浅拷贝问题

1、vector迭代器失效问题

1.1、insert迭代器失效

insert迭代器失效分为两类：

扩容导致野指针
意义变了

下面我们先给出insert的初始版本，然后再逐渐的完善：

void insert(iterator pos, const T& x)
{
	//检测参数合法性
	assert(pos >= _start && pos <= _finish);
	//检测是否需要扩容
	if (_finish == _endofstoage)
	{
		size_t newcapcacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapcacity);
	}
	//挪动数据
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *(end);
		end--;
	}
	//把值插进去
	*pos = x;
	_finish++;
}

扩容导致野指针

我们给出以下两组测试用例：

这里为什么push_back尾插4个后调用insert会出现随机值？而push_back尾插5个调用insert就没有这个问题？

此问题就是迭代器失效，原因就在于pos没有更新，导致非法访问野指针。

上述当尾插4个数字后，再头插一个数字发生扩容。根据reserve扩容机制，_start和_finish都会更新，唯独插入位置pos没有更新，此时pos依旧指向旧空间，reserve后会释放旧空间，此时的pos就是野指针，这也就导致后续执行*pos=x就是非法访问野指针。

解决方法

我们可以设定变量n来计算扩容前pos指针位置和_start指针位置的相对距离，最后在扩容后，让_start再加上先前算好的相对距离n就是更新后的pos指针的位置了。

修正如下
void insert(iterator pos, const T& x)
{
	//检测参数合法性
	assert(pos >= _start && pos <= _finish);
	/*扩容以后pos就失效了，需要更新一下*/
	if (_finish == _endofstoage)
	{
		size_t n = pos - _start;//计算pos和start的相对距离
		size_t newcapcacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapcacity);
		pos = _start + n;//防止迭代器失效，要让pos始终指向与_start间距n的位置
	}
	//挪动数据
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *(end);
		end--;
	}
	//把值插进去
	*pos = x;
	_finish++;
}

意义变了

比如现在我要在所有的偶数前面插入2，下面我们看测试结果：

这里发生了断言错误，这段代码发生了两个错误：

it是指向原空间的，当insert插入要扩容时，原空间的数据拷贝到新空间上，但这也就意味着旧空间全是野指针，而it是一直指向旧空间的，随后遍历it时就非法访问野指针，也就失效了。形参的改变不会影响实参，即使你内部pos指向改变了，但是并不会影响我外部的it。
为了解决上述问题，有人觉得提前reserve开辟足够大的空间即可避免发生野指针的现象，但是又会出现一个新的问题，我们看下图：

此时insert以后虽然没有扩容，it也并没有成为野指针，但是it指向位置意义变了，导致我们这个程序重复插入20。

解决方法：

给insert函数加上返回值即可解决，返回指向新插入元素的位置。
iterator insert(iterator pos, const T& x)
{
	//检测参数合法性
	assert(pos >= _start && pos <= _finish);
	//检测是否需要扩容
	/*扩容以后pos就失效了，需要更新一下*/
	if (_finish == _endofstoage)
	{
		size_t n = pos - _start;//计算pos和start的相对距离
		size_t newcapcacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapcacity);
		pos = _start + n;//防止迭代器失效，要让pos始终指向与_start间距n的位置
	}
	//挪动数据
	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *(end);
		end--;
	}
	//把值插进去
	*pos = x;
	_finish++;
	return pos;
}
我们实际调用的时候也需要改动，让it自己接收insert后的返回值：

官方库windows下VS和linux下对insert迭代器失效的处理

VS：针对于扩容发生野指针类的迭代器失效，VS官方库是直接断言报错。

Linux：linux下可以直接进行访问，甚至是可以进行修改。

1.2、erase迭代器失效

我们给出erase模拟实现的代码：
iterator erase(iterator pos)
{
	//检查合法性
	assert(pos >= _start && pos < _finish);
	//从pos + 1的位置开始往前覆盖，即可完成删除pos位置的值
	iterator it = pos + 1;
	while (it < _finish)
	{
		*(it - 1) = *it;		
        it++;
	}
	_finish--;
	return pos;
}
erase的失效都是意义变了，或者不在有效访问数据的有效范围内
erase一般不会使用缩容的方案，那么也就导致erase的失效一般不存在野指针的失效。

我们现在对下面代码进行测试：
void test_vector()
{
	Fan::vector<int> v;
	//v.reserve(10);
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	cout << v.size() << ":" << v.capacity() << endl;
	auto pos = find(v.begin(), v.end(), 2);
	if (pos != v.end())
	{
		v.erase(pos);
	}
	cout << *pos << endl;
	*pos = 10;
	cout << *pos << endl << endl;
	cout << v.size() << ":" << v.capacity() << endl;
	for (auto e : v)
	{
		cout << e << " ";
	}
}
我们尾插4个数字，比较size和capacity的大小，此时是相等的，接下来删除值为2的数，此时*pos就是删除数字的下一个数据也就是3，此时有效数据也少了一个，后续修改*pos也就不存在问题。

如果我们这里要删除的值为4，那么结果会是怎么样的呢？

我们这里一共有4个数据，按理说把最后一个数字删除以后，有效数字-1，不存在还会访问最后一个值的现象，但是此结果却是删除4以后又访问了4，而且还修改4为10，这就是典型的erase迭代器失效。

官方库windows下VS和linux下对erase迭代器失效的处理

VS：VS检查环境十分的严格，直接强制检查断言错误。

Linux：Linux下对于迭代器失效的检查宽泛很多，并不会报错。

结论

erase(pos)以后pos失效了，pos的意义变了，但是在不同平台下面对于访问pos的反应是不一样的，我们用的时候要以失效的角度去看待此问题。
对于insert和erase造成迭代器失效问题，linux的g++平台检查很佛系，基本靠操作系统本身野指针越界检查机制。windows下VS系列检查更严格一些，使用一些强制检查机制，意义变了可能会检查出来。
虽然g++对于迭代器失效检查时是非常佛系的，但是套在实际场景中，迭代器意义变了，也会出现各种问题。

下面我们再给出一组测试用例：
void test_vector()
{
	//删除所有的偶数
	vector<int> v;
	//v.reserve(10);
	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 << " ";
	}

}
代码直接崩溃。

画图演示错误过程：
解决方案如下：
void test_vector()
{
	//删除所有的偶数
	std::vector<int> v;
	//v.reserve(10);
	v.push_back(1);
	v.push_back(2);
	v.push_back(2);
	v.push_back(2);
	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)
		{
			it = v.erase(it);
		}
		else
		{
			it++;
		}
	}
	for (auto e : v)
	{
		cout << e << " ";
	}
}

1.3、迭代器失效总结

vector迭代器失效有两种

扩容、缩容导致野指针式失效
迭代器指向的位置意义变了

系统越界机制检查，不一定能够检查到。编译实现检查机制，相对比较靠谱。

2、深浅拷贝问题

我们用先前模拟实现的vector来测试杨辉三角以此来解释深浅拷贝问题：
namespace Fan
{
	class Solution {
	public:
		// 核心思想：找出杨辉三角的规律，发现每一行头尾都是1，中间第[j]个数等于上一行[j-1]+[j]
		vector<vector<int>> generate(int numRows) {
			vector<vector<int>> vv;
			// 先开辟杨辉三角的空间
			vv.resize(numRows);
			for (size_t i = 1; i <= numRows; ++i)
			{
				vv[i - 1].resize(i, 0);
				// 每一行的第一个和最后一个都是1
				vv[i - 1][0] = 1;
				vv[i - 1][i - 1] = 1;
			}
			for (size_t i = 0; i < vv.size(); ++i)
			{
				for (size_t j = 0; j < vv[i].size(); ++j)
				{
					if (vv[i][j] == 0)
					{
						vv[i][j] = vv[i - 1][j - 1] + vv[i - 1][j];
					}
				}
			}
			return vv;
		}
	};

	void test()
	{
		vector<vector<int>> vv = Solution().generate(5);
		for (size_t i = 0; i < vv.size(); ++i)
		{
			for (size_t j = 0; j < vv[i].size(); ++j)
			{
				cout << vv[i][j] << " ";
			}
			cout << endl;
		}
	}
}
理想结果如下：

测试结果如下：

我们把初版扩容代码给出：
//reserve扩容
void reserve(size_t n)
{
	size_t sz = size();//提前算出size()的大小，方便后续更新_finish
	if (n > capacity())
	{
		T* tmp = new T[n];
		if (_start)//判断旧空间是否有数据
		{
			memcpy(tmp, _start, sizeof(T) * size());
			delete[] _start;//释放旧空间
		}
		_start = tmp;//指向新空间
	}
	//更新_finish和_endofstoage
	_finish = _start + sz;
	_endofstoage = _start + n;
}
分析如下：

我们仔细看上面，我们调用类Solution返回对象vv的临时拷贝，然后将临时拷贝对象赋值给test函数里面的vv，这里就涉及类对象的拷贝构造，我们看一下拷贝构造函数：

拷贝构造函数这里是创建了新的对象tmp，然后拿参数v的值将其初始化，所以这里涉及类的构造函数，下面我们看一下构造函数：

我们能够看到的是构造函数是把传过来的数据一个个尾插到容器里面去，问题就出在了这里的push_back上面。因为当我们要插入第五个数据的时候是需要扩容的：

总结：

vector<T>中，当T涉及深浅拷贝的类型时，如：string/vector<T>等等，我们扩容使用memcpy拷贝数据是存在浅拷贝问题。
memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中。
如果拷贝的是自定义类型的元素，memcpy即高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。

解决方案：

reserve扩容时不使用memcpy，我们改用for循环来解决：
//reserve扩容
void reserve(size_t n)
{
	size_t sz = size();//提前算出size()的大小，方便后续更新_finish
	if (n > capacity())
	{
		T* tmp = new T[n];
		if (_start)//判断旧空间是否有数据
		{
			//不能用memcpy，因为memcpy是浅拷贝
			for (size_t i = 0; i < size(); i++)
			{
				tmp[i] = _start[i];
			}
			delete[] _start;//释放旧空间
		}
		_start = tmp;//指向新空间
	}
	//更新_finish和_endofstoage
	_finish = _start + sz;
	_endofstoage = _start + n;
}

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
vector迭代器失效与深浅拷贝问题

详细讲述vector迭代器失效问题以及处理情况。
复制链接

扫一扫

专栏目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。