深入篇【C++】谈vector中的深浅拷贝与迭代器失效问题
- Ⅰ.深浅拷贝问题
- 1.内置类型深拷贝
- 2.自定义类型深拷贝
- Ⅱ.迭代器失效问题
- 1.内部迭代器失效
- 2.外部迭代器失效
Ⅰ.深浅拷贝问题
1.内置类型深拷贝
浅拷贝是什么意思？就是单纯的值拷贝。
浅拷贝的坏处：
①空间会析构两次。
②一个修改会影响另一个。
根据上一篇vector的模拟实现中需要用到拷贝的有三个函数，一个是拷贝构造，一个是赋值重载，一个是扩容。都需要用深度拷贝。深度拷贝是什么意思呢？
就是开出一块空间，将原空间的数据拷贝过来。有时候还需要将原空间释放掉。
我们可以看一下手搓的vector中的扩容，就是采用的深度拷贝。
void reserve(size_t n)
{
size_t sz = size();
if (n > capacity())
{
T* temp = new T[n];//首先开空间
if (_start != nullptr)
{
//将数据拷贝到temp去
memcpy(temp, _start, sizeof(T) * sz);
//删除原来空间
delete[] _start;
}
//最后将空间赋值给_start
_start = temp;
_finish = _start + sz;
//这里有一个问题，size()的计算是用_finish -start 而这里的start已经改变，而finish还没有改变
//最后计算finish就变成空了，最终的问题在于start改变了，所有在之前要保留一份size()的数据
_endstroage = _start + n;
}
}
这里利用memcpy函数将数据按照字节的方式将start指向的数据一个一个拷贝到temp指向的空间里。
这个是没有问题的，有问题的是这种情况：当vector<string> 类型的数据扩容时，会有隐藏的深拷贝。
我们知道上面的数据是vector<int>类型的。即内置类型，内置类型使用memcpy按照字节的方式拷贝是没有问题的。
但是不是内置类型而是自定义类型时，利用memcpy拷贝可以吗？
void Test4()
{
tao::vector<string> v;
v.push_back("11111111111111111111111");
v.push_back("22222222222222222222222");
v.push_back("33333333333333333333333");
v.push_back("44444444444444444444444");
//v.push_back("55555555555555555555555");
for (auto e : v)
{
cout << e << " ";
}
}
当前数据实际大小并没有超过容量，所以没有扩容， 也没有发生拷贝，所以正常，但一旦我们再插入一个数据，就会扩容，这时原来的空间就会被释放，那么能正常打印吗？
很明显运行错误，为什么呢？
2.自定义类型深拷贝
memcpy是按照字节拷贝的，拷贝完后的数据内容肯定是一样的，所以_str会指向同一块数据。而当拷贝完后原空间就会被释放掉，则temp里的_str就变成野指针了。
vector是深拷贝，但vector空间上存的对象是string类型的数组，使用memcpy会导致string对象的浅拷贝。
【解决方案】
所以我们期望这个对象能进行深拷贝，就比如这个对象是string类型的，我们希望能调用这个自定义类型的深拷贝。而对于那些深拷贝的自定义类型来说，赋值重载必须是深拷贝的，所以我们可以使用这个自定义类型的赋值重载来完成深拷贝。
//扩容------>
void reserve(size_t n)
{
size_t sz = size();
if (n > capacity())
{
T* temp = new T[n];//首先开空间
if (_start != nullptr)
{
//将数据拷贝到temp去
//memcpy(temp, _start, sizeof(T) * sz);
for (size_t i = 0; i < sz; i++)
{
temp[i] = _start[i];
//比如_start[i] 是string类型的数据，那么这里赋值给temp就会调用赋值运算符重载，而string的赋值运算符重载是深度拷贝的。
}
//删除原来空间
delete[] _start;
}
//最后将空间赋值给_start
_start = temp;
_finish = _start + sz;
//这里有一个问题，size()的计算是用_finish -start 而这里的start已经改变，而finish还没有改变
//最后计算finish就变成空了，最终的问题在于start改变了，所有在之前要保留一份size()的数据
_endstroage = _start + n;
}
}
这样原空间释放了，并不会影响temp空间里的数据。这就是隐藏的深拷贝，对于vector<T>呢，如果T是内置类型，使用memcpy就可以解决深浅拷贝，但对于T是自定义类型，memcpy就无法完成深拷贝了，需要使用到T类型的赋值重载来深度拷贝。不过这种方法对于内置类型也是可以完成任务的。
所以我们应该将有拷贝的地方都换成上面的写法，而不是用memcpy来完成拷贝。
//拷贝构造------->
vector(const vector<T>& v)//深拷贝
: _start(nullptr)
, _finish(nullptr)
, _endstroage(nullptr)
{
_start = new T[v.size()];
//memcpy(_start, v._start, sizeof(T) * v.size());
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
_finish = _start+v.size();
_endstroage = _start+v.capacity();
}
Ⅱ.迭代器失效问题
1.内部迭代器失效
迭代器在遍历访问的时候非常好用，但有的情况下迭代器会发生失效。
什么情况下迭代器会发生失效呢？
①会引起底层空间改变的操作，都有可能引起迭代器失效，比如insert或者push_back插入一个数据时，发生扩容。
②erase删除一个数据时，迭代器发生失效。
什么叫迭代器失效呢？就是不能再访问这个迭代器了，正常使用这个迭代器了。
vector和string都有insert和erase，为什么string没有这个问题呢？因为string中的insert和erase用的不是迭代器而是下标。
比如insert(iteraort pos，const T&val)在pos位置插入数据时，首先会检查是否需要扩容，发现需要扩容时，会开出2倍空间，将原数据拷贝下来，然后再将原空间释放，最后将temp空间赋给start。
这时就要注意到pos迭代器就已经失效了，为什么？因为pos迭代器原先指向的空间被释放了，现在的pos迭代器就类似一个野指针，危险的很，不能再去使用了。那这时insert插入的pos位置就是一个未知的空间了，肯定会报错的。
【解决方法】
这里pos因为原空间被释放了，变成野指针了，扩容完后的start指向的空间正常，但再去往pos位置去插入数据这就危险了。问题就在于pos位置，我们应该在扩容直接记录一下pos的相对位置，然后扩容后，再更新一下pos的新位置，这样pos迭代器就不会失效了。
iterator insert(iterator pos,const T &val)
{
assert(pos >= _start && pos <= _finish);
//首先考虑扩容----这里有一个问题：迭代器失效
//当迭代器扩容时，这里的pos迭代器就相当于失效了，因为原来的空间被释放了，pos也就变成野指针了。
//需要将将pos迭代器恢复，需要更新pos的新位置。
if (_finish == _endstroage)
{
-------------> size_t len = pos - _start;
size_t newcapacity = (capacity() == 0 ? 4 : capacity() * 2);
reserve(newcapacity);
pos = _start + len;
}
//使用迭代器的好处就是可以避免string那样头插时，挪动数据，下标要小于0的问题，因为迭代器是一个地址，不可以为0的
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
end--;
}
*pos = val;
_finish++;
//insert 中的扩容迭代器失效，外部迭代器的解决方法是使用返回值，将pos位置返回过去，再用迭代器接收，就可以对pos位置上的内容再访问了
return pos;
//指向新插入位置的迭代器
}
2.外部迭代器失效
v里面已经有了4个数据1，2，3，4这时候再在第三个位置插入一个800。
然后再对这个插入位置上的数据修改一下，给这个数据加上1000。
这里的迭代器失效的原因还是因为原空间被销毁，pos位置变成野指针了。要注意虽然我们已经完善了内部迭代器失效，但因为这里是传值传参，形参的改变不会影响实参，虽然形参的迭代器不会失效，但是实参还是会失效的。
所以这里再次访问这个it指向的空间时，就是非法的了，因为it指向的空间被释放了。
tao::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
tao::vector<int>::iterator it = v.begin()+3;
v.insert(it, 800);//这里的it--->pos 形参的改变不影响实参
//这里的it迭代器失效了，访问的不是第三个位置了。
*it += 1000;
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
而标准库里的insert也会遇到这样的问题，那么库里的insert是如何解决这个问题的呢？
库里是用返回值的方法来解决的，也就的将插入数据的位置返回回去，用it来接收，那么虽然形参改变无法改变实参，但最后将改变后的形参以返回值的方式再传给实参，实参就有效了。
tao::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
tao::vector<int>::iterator it = v.begin()+3;
it=v.insert(it, 800);
//用返回值的方式将有效的迭代器(指向插入元素的位置)传送回来，那样it就可以使用访问了。
*it += 1000;
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
以上就是insert插入操作引起的迭代器失效问题。接下来我将介绍因为erase删除操作而引起的迭代器问题。
erase操作为什么会引起迭代器失效呢？
1.这里的问题不是类似于空间销毁，变成野指针了，而是这个迭代器代表的位置的意义改变了，指向的内容不一样了。删除pos位置上的元素，pos位置之后的元素就会往前挪动覆盖，pos位置的元素就变成了一个新的元素了。在VS下这个行为就认定为迭代器失效了。
2.即erase以后，迭代器就失效，不能再访问，vs会进行强制检查，如果访问会直接报错。
以下面这个代码为例子：删除vector中的所有偶数
tao::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(4);
v.push_back(4);
v.push_back(6);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
tao::vector<int>::iterator it = v.begin();
while (it != v.end())
{
if ((*it) % 2 == 0)
{
v.erase(it);//这里erase完，it迭代器就失效了，就无法再访问其内容了，比如连续2个的偶数，第一个被删除后，it位置就变成第二偶数了，但这个位置已经失效了，所以这个偶数就无法正常删除掉了。
//1 2 2 3 第一个2可以删除，第二个2无法删除掉。
}
else
{
++it;//迭代器已经失效了，不能再对这个迭代器操作了。
}
}
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
而正常做法应该是，每次删除完这个位置上的元素后，都要重新赋值更新一下it，库里的做法就是将erase删除位置的下一个元素的位置返回回去，这样it就会更新成被删除元素的的下一个位置。
tao::vector<int>::iterator it = v.begin();
while (it != v.end())
{
if ((*it) % 2 == 0)
{
it=v.erase(it);//正常使用：在每次删除完后，对迭代器重新赋值即可。
}
else
{
++it;
}
}
Linux和vs下对于erase删除元素后迭代器是否失效是不同的，VS下对于迭代器的失效检测非常严格，非常极端，而g++的编译器对于迭代器检测就不是很严格了。
