Ⅰ.深浅拷贝问题

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++的编译器对于迭代器检测就不是很严格了。