目录

一、vector迭代器失效问题

1、resize,reserve,insert,assign,push_back可能引起底层空间改变

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

3、Linux下，g++编译器对迭代器失效的检测不是非常严格，处理也没有vs下极端

4、与vector类似，string在插入+扩容操作+erase之后，迭代器也会失效

二、memcpy拷贝问题

三、动态二维数组

---

一、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();
	v.resize(100, 8);
	v.reserve(100);
	v.insert(v.begin(), 0);
	v.push_back(8);
	v.assign(100, 8);
	//it还使用的是释放之前的旧空间
	//解决方式：只需给it重新赋值
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	return 0;
}

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

如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。

int main()
{
	int a[] = { 1,2,3,4 };
	vector<int> v(a, a + sizeof(a) / sizeof(int));
	vector<int>::iterator pos = find(v.begin(), v.end(), 3);
	v.erase(pos);
	cout << *pos << endl;
	return 0;
}

删除vector中的所有偶数，看看哪个代码是正确的？

😀😀😀🐕🐕🐕🤔🤔🤔

int main()
{
	vector<int> v{ 1,2,3,4 };
	auto it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			v.erase(it);
		}
	}
	return 0;
}
int main()
{
	vector<int> v{ 1,2,3,4 };
	auto it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			it = v.erase(it);
		}
		else
		{
			++it;
		}
	}
	return 0;
}

3、Linux下，g++编译器对迭代器失效的检测不是非常严格，处理也没有vs下极端

// 1. 扩容之后，迭代器已经失效了，程序虽然可以运行，但是运行结果已经不对了
int main()
{
	vector<int> v{ 1,2,3,4,5 };
	for (size_t i = 0; i < v.size(); ++i)
		cout << v[i] << " ";
	cout << endl;
	auto it = v.begin();
	cout << "扩容之前，vector的容量为: " << v.capacity() << endl;
	// 通过reserve将底层空间设置为100，目的是为了让vector的迭代器失效
	v.reserve(100);
	cout << "扩容之后，vector的容量为: " << v.capacity() << endl;
	// 经过上述reserve之后，it迭代器肯定会失效，在vs下程序就直接崩溃了，但是linux下不会
	// 虽然可能运行，但是输出的结果是不对的
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	return 0;
}
程序输出：
1 2 3 4 5
扩容之前，vector的容量为: 5
扩容之后，vector的容量为 : 100
0 2 3 4 5 409 1 2 3 4 5
// 2. erase删除任意位置代码后，linux下迭代器并没有失效
// 因为空间还是原来的空间，后序元素往前搬移了，it的位置还是有效的
#include <vector>
#include <algorithm>
int main()
{
	vector<int> v{ 1,2,3,4,5 };
	vector<int>::iterator it = find(v.begin(), v.end(), 3);
	v.erase(it);
从上述三个例子中可以看到：SGI STL中，迭代器失效后，代码并不一定会崩溃，但是运行结果肯定不
		对，如果it不在begin和end范围内，肯定会崩溃的。
		4. 与vector类似，string在插入 + 扩容操作 + erase之后，迭代器也会失效
		cout << *it << endl;
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	return 0;
}
程序可以正常运行，并打印：
4 4
5
// 3: erase删除的迭代器如果是最后一个元素，删除之后it已经超过end
// 此时迭代器是无效的，++it导致程序崩溃
int main()
{
	vector<int> v{ 1,2,3,4,5 };
	// vector<int> v{1,2,3,4,5,6};
	auto it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
			v.erase(it);
		++it;
	}
	for (auto e : v)
		cout << e << " ";
	cout << endl;
	return 0;
}
========================================================
// 使用第一组数据时，程序可以运行
[sly@VM - 0 - 3 - centos 20220114]$ g++ testVector.cpp - std = c++11
[sly@VM - 0 - 3 - centos 20220114]$ . / a.out
1 3 5
======================================================== =
// 使用第二组数据时，程序最终会崩溃
[sly@VM - 0 - 3 - centos 20220114]$ vim testVector.cpp
[sly@VM - 0 - 3 - centos 20220114]$ g++ testVector.cpp - std = c++11
[sly@VM - 0 - 3 - centos 20220114]$ . / a.out
Segmentation fault

4、与vector类似，string在插入+扩容操作+erase之后，迭代器也会失效

#include<string>
void TestString()
{
	string s("hello");
	auto it = s.begin();
	//s.resize(20,'!');
	while (it != s.end())
	{
		cout << *it;
		++it;
	}
	cout << endl;
	it = s.begin();
	while (it != s.end())
	{
		it = s.erase(it);
		//s.erase(it);
		++it;
	}
}

二、memcpy拷贝问题

如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，可能会引起内存泄漏甚至程序崩溃。

1. memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中
2. 如果拷贝的是自定义类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝

 

三、动态二维数组

 以杨辉三角为例：

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> vv(numRows);
        for(int i=0;i<numRows;++i)
        {
            vv[i].resize(i+1,1);

        }
        for(int i=2;i<numRows;++i)
        {
            for(int j=1;j<i;++j)
            {
                vv[i][j]=vv[i-1][j]+vv[i-1][j-1];
            }
        }
        return vv;
    }
};

(vv.operator[](i)).operator[j]

通过两次operator[]的调用，像访问二维数组一样访问第i行的第j列的数据，本质是先访问第i个vector<int>对象，再访问这个对象的第j个int数据。