vector迭代器失效问题

目录

迭代器失效原因

野指针导致失效

迭代器无法遍历所有有效空间位置

---

迭代器失效原因

在vector底层实现的过程中有一个问题，那就是迭代器突然失效，造成程序崩溃的情况。失效的原因大致有2 种：野指针导致失效、迭代器无法遍历所有有效空间位置。

野指针导致失效

情况一：内部迭代器失效

在实现insert接口时，会碰到该类情况。

首先查看一下库里是如何实现insert接口的：

 我们先来实现第一个insert，库里传参第一个参数传的是迭代器pos，vector中使用迭代器标识插入位置而非下标，第二个参数则是模板参数的const引用。

这里先给出我的整体框架：

namespace bc
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;

	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};
}

在插入之前要先考虑传参pos的可能位置，pos一定是在 [ _start , _finish) 所以可以先断言一下pos:

			assert(pos >= _start);
			assert(pos < _finish);

然后是 是否需要扩容的问题，当_finish == _end_of_storage时需要扩容，扩容接口：

		void reserve(size_t n) {
			if (n > capacity()) {
				size_t oldsize = size();
				T* tmp = new T[n];
				if (_start != nullptr) {
					memcpy(tmp, _start, sizeof(T) * size());
					delete[]_start;
				}
				_start = tmp;
				_finish = tmp + oldsize;
				_end_of_storage = _start + n;
			}
		}

扩容就是开辟新空间，拷贝数据到新空间，释放旧空间，再让_start 指向新空间就可以了。

最后调整一下新空间对应的_finish 和 _end_of_storage。

接下来就是挪动数据，插入数据就完成了。这里挪动数据比较方便，也不用考虑边界，因为是指针。

			iterator end = _finish - 1;
			while (end >= pos) {
				*(end + 1) = *(end);
				--end;
			}
			*pos = x;
			_finish++;

整体代码：

		void insert(iterator pos, const T& x) {
			assert(pos >= _start);
			assert(pos < _finish);
			if (_finish == _end_of_storage) {
				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);
			}
			iterator end = _finish - 1;
			while (end >= pos) {
				*(end + 1) = *(end);
				--end;
			}
			*pos = x;
			_finish++;
		}

尝试测试运行：

vector<int> a;
		a.push_back(1);
		a.push_back(1);
		a.push_back(1);
		a.push_back(1);
		for (auto e : a) {
			cout << e << " ";
		}
		cout << endl;

		a.insert(a.begin(), 0);

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

 我们进行头插，发现程序崩溃了，调试程序锁定错误原因在扩完容后pos越界了：

 在扩容执行之前，pos还未越界，尚在 [_start,_finish)范围内

 当扩容执行后，pos不在上面范围内越界了，此时就是个野指针，程序崩溃。

那为什么pos会越界变成野指针呢？

————问题肯定在于扩容，如果先给足空间不扩容，上述代码头插是不会有问题的。

在扩容的时候，_start旧空间被释放了，而pos迭代器是指向_start的，所以释放完后pos就变成了野指针。

 针对这种情况，在扩容后重新设置pos指向，让它指向新空间正确的位置就可以了：

		void insert(iterator pos, const T& x) {
			assert(pos >= _start);
			assert(pos < _finish);
			if (_finish == _end_of_storage) {
				size_t len = pos - _start;
				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);
				pos = _start + len;
			}
			iterator end = _finish - 1;
			while (end >= pos) {
				*(end + 1) = *(end);
				--end;
			}
			*pos = x;
			_finish++;
		}

情况二：外部迭代器失效

还是野指针导致的迭代器失效。

通过算法库的find函数查找指定位置插入：

		vector<int>::iterator it = find(a.begin(), a.end(), 1);
		if (it != a.end()) {
			a.insert(it, 2);
		}
		for (auto e : a) {
			cout << e << " ";
		}
		cout << endl;

这样可以实现find + insert的操作，那么插入完后还可以使用 it 吗？

 似乎没问题，编译器也没报错。实际上这里是不可以再使用 it 的，此时 it 其实已经越界了，是个野指针，和上面问题一样，迭代器已经失效。

有人会问：上面不是已经解决越界问题了吗？扩容后pos位置重新调整了，为什么还会越界？

————因为pos是形参，函数内形参的改变对外面的实参没有影响，调整了pos不代表外面实参it也会调整。

那么为什么编译器没有报错呢？————对于越界编译器是抽查，并不是一定能检查出来的，临近位置可能检查的出来，但大概率还是检查不出来。这不意味着越界没事，相反这种不搞错的潜在危险更可怕，它会悄悄在你意想不到的地方造成严重问题。

因此这里不要继续使用it，即使没有越界也不要使用！

迭代器无法遍历所有有效空间位置

该问题主要是由erase函数引发的，下面我在VS2019 和 Linux 两个平台下分别进行测试。

VS2019平台下：

	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	std::vector<int>::iterator it = v.begin();
	while (it != v.end()) {
		if ((*it) % 2 == 0) {
			v.erase(it);
		}
		++it;
	}
	for (auto e : v) {
		cout << e << " ";
	}
	cout << endl;

创建一个顺序表v，里面元素{1,2,3,4}; 通过迭代器从头遍历，如果是偶数就删除。

运行起来结果程序崩溃。

在Linux平台下：

报错：段错误。一般来说这种错误是越界造成的。

我们来看一下是哪里的原因：

 erase实现代码（我们写的不带返回值的简化版本）：

		void erase(iterator pos) {
			assert(pos >= _start);
			assert(pos < _finish);
			iterator begin = pos + 1;
			while (begin < _finish) {
				*(begin-1) = *(begin);
				++begin;
			}
			_finish--;
		}

所谓删除其实就是挪动数据从后往前覆盖。

上述情况下会出现 it 跑到 _finish后面的情况，从而 it 碰不到 _finish程序崩溃。

如果vector<int> v 里面数据改一下，改成{1,2,3,4,5}；

VS2019平台下：

 依旧程序崩溃。

Linux平台下：

 结果是 1 3 5，与VS2019下不一样，这是怎么回事？

————这是由于VS和Linux两者使用的库不一样，VS是PJ版，检查比较严格，它的迭代器实现不是原生指针实现，而是将迭代器封装成一个类，并做了很多处理(包括很多操作符重载)；

Linux的g++编译器使用的库检查相对没有那么严格，与我们上面实现类似。我们来看一下这种情况下为什么Linux下能编译通过（我的底层实现就是按Linux使用的库写的）

 这样刚好能覆盖删除所有偶数并且结束循环，可以说是巧合情况，至于VS2019下为什么报错刚刚已经说过是实现方式不同检查严格。

如果vector<int> v 里面数据再改一下，改成{1,2,3,4,4,5}；

VS2019下依旧跑不过，Linux下编译通过但是结果不对：

 预期答案是1 3 5 ，这里少删除了4，还是画图解释：

 那么让 it 在奇数的情况下++，偶数的情况下不动就可以避免这种情况的发生：

    std::vector<int>::iterator it = v.begin();
	while (it != v.end()) {
		if ((*it) % 2 == 0) {
			v.erase(it);
		}
		else{
           ++it;
        }
	}
	for (auto e : v) {
		cout << e << " ";
	}
	cout << endl;

修改成功！

但是这种修改并不能保证其他情况下的正确性，所以得找一个能解决所有场景的方法。

我们来看一下库里是怎么解决的：

 库里是通过返回迭代器解决的，这样就可以通过返回值更新迭代器的位置从而使得 it 能指向所有有效位置。返回值返回的迭代器是删除元素的下一个位置。

完整代码：

iterator erase(iterator pos) {
			assert(pos >= _start);
			assert(pos < _finish);
			iterator begin = pos + 1;
			while (begin < _finish) {
				*(begin-1) = *(begin);
				++begin;
			}
			_finish--;
			return pos;
		}

	void Test3() {
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(4);
		v.push_back(5);
		vector<int>::iterator 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; 
	}

结果：