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

#include 
using namespace std;
#include 
int main()
{int a[] = { 1, 2, 3, 4 };vector v(a, a + sizeof(a) / sizeof(int));// 使用find查找3所在位置的iteratorvector::iterator pos = find(v.begin(), v.end(), 3);// 删除pos位置的数据，导致pos迭代器失效。v.erase(pos);cout << *pos << endl; // 此处会导致非法访问return 0;
}

#include 
using namespace std;
#include 
int main()
{vector v{ 1, 2, 3, 4 };auto it = v.begin();while (it != v.end()){if (*it % 2 == 0)v.erase(it);++it;} return 0;
}int main()
{vector 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;
}

第一个代码是错误的，会造成迭代器失效，且其删除逻辑是不对的。以上面的代码为例，当程序删除“2”以后，pos位置会变成“3”，然后it++,迭代器就指向了4，就错过了对3的判断，且最后一个是偶数4，删除以后，迭代器会超过_finish,导致it永远不会==v.end()。

3. Linux下，g++编译器对迭代器的处理情况。

// 1. 扩容之后，迭代器已经失效了，程序虽然可以运行，但是运行结果已经不对了
int main()
{vector v{1,2,3,4,5};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;
}
输出：
扩容之前，vector的容量为: 5
扩容之后，vector的容量为: 100
0 2 3 4 5 409 1 2 3 4 5// 2. erase删除任意位置代码后，linux下迭代器并没有失效
// 因为空间还是原来的空间，后序元素往前搬移了，it的位置还是有效的
#include 
#include 
int main()
{vector v{1,2,3,4,5};vector::iterator it = find(v.begin(), v.end(), 3);v.erase(it);
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 v{1,2,3,4,5};// vector 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;
}

从上述三个例子中可以看到：Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端，SGI STL中，迭代器失效后，代码并不一定会崩溃，但是运行结果肯定不对，如果it不在begin和end范围内，肯定会崩溃的。

二.vector深度剖析及模拟实现

1.std::vector的核心框架接口的模拟实现

#pragma once#include 
using namespace std;
#include namespace Kevin
{templateclass vector{public:// Vector的迭代器是一个原生指针typedef T* iterator;typedef const T* const_iterator;///// 构造和销毁vector(): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr){}vector(size_t n, const T& value = T()): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr){reserve(n);while (n--){push_back(value);}}/** 理论上将，提供了vector(size_t n, const T& value = T())之后* vector(int n, const T& value = T())就不需要提供了，但是对于：* vector v(10, 5);* 编译器在编译时，认为T已经被实例化为int，而10和5编译器会默认其为int类型* 就不会走vector(size_t n, const T& value = T())这个构造方法，* 最终选择的是：vector(InputIterator first, InputIterator last)* 因为编译器觉得区间构造两个参数类型一致，因此编译器就会将InputIterator实例化为int* 但是10和5根本不是一个区间，编译时就报错了* 故需要增加该构造方法*/vector(int n, const T& value = T()): _start(new T[n]), _finish(_start+n), _endOfStorage(_finish){for (int i = 0; i < n; ++i){_start[i] = value;}}// 若使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器// 重新声明迭代器，迭代器区间[first,last)可以是任意容器的迭代器templatevector(InputIterator first, InputIterator last){while (first != last){push_back(*first);++first;}}vector(const vector& v): _start(nullptr), _finish(nullptr), _endOfStorage(nullptr){reserve(v.capacity());iterator it = begin();const_iterator vit = v.cbegin();while (vit != v.cend()){*it++ = *vit++;}_finish = it;}vector& operator=(vector v){swap(v);return *this;}~vector(){if (_start){delete[] _start;_start = _finish = _endOfStorage = nullptr;}}/// 迭代器相关iterator begin(){return _start;}iterator end(){return _finish;}const_iterator cbegin() const{return _start;}const_iterator cend() const{return _finish;}//// 容量相关size_t size() const { return _finish - _start; }size_t capacity() const { return _endOfStorage - _start; }bool empty() const { return _start == _finish; }void reserve(size_t n){if (n > capacity()){size_t oldSize = size();// 1. 开辟新空间T* tmp = new T[n];// 2. 拷贝元素// 这里直接使用memcpy会有问题吗？同学们思考下//if (_start)//	memcpy(tmp, _start, sizeof(T)*size);if (_start){for (size_t i = 0; i < oldSize; ++i)tmp[i] = _start[i];// 3. 释放旧空间delete[] _start;}_start = tmp;_finish = _start + oldSize;_endOfStorage = _start + n;}}void resize(size_t n, const T& value = T()){// 1.如果n小于当前的size，则数据个数缩小到nif (n <= size()){_finish = _start + n;return;}// 2.空间不够则增容if (n > capacity())reserve(n);// 3.将size扩大到niterator it = _finish;_finish = _start + n;while (it != _finish){*it = value;++it;}}///// 元素访问T& operator[](size_t pos) { assert(pos < size());return _start[pos]; }const T& operator[](size_t pos)const { assert(pos < size());return _start[pos]; }T& front(){return *_start;}const T& front()const{return *_start;}T& back(){return *(_finish - 1);}const T& back()const{return *(_finish - 1);}/// vector的修改操作void push_back(const T& x) { insert(end(), x); }void pop_back() { erase(end() - 1); }void swap(vector& v){std::swap(_start, v._start);std::swap(_finish, v._finish);std::swap(_endOfStorage, v._endOfStorage);}iterator insert(iterator pos, const T& x){assert(pos <= _finish);// 空间不够先进行增容if (_finish == _endOfStorage){//size_t size = size();size_t newCapacity = (0 == capacity()) ? 1 : capacity() * 2;reserve(newCapacity);// 如果发生了增容，需要重置pospos = _start + size();}iterator end = _finish - 1;while (end >= pos){*(end + 1) = *end;--end;}*pos = x;++_finish;return pos;}// 返回删除数据的下一个数据// 方便解决:一边遍历一边删除的迭代器失效问题iterator erase(iterator pos){// 挪动数据进行删除iterator begin = pos + 1;while (begin != _finish) {*(begin - 1) = *begin;++begin;}--_finish;return pos;}private:iterator _start;		// 指向数据块的开始iterator _finish;		// 指向有效数据的尾iterator _endOfStorage;  // 指向存储容量的尾};
}

2. 使用memcpy拷贝问题

int main()
{bite::vector v;v.push_back("1111");v.push_back("2222");v.push_back("3333");return 0;
}

假设模拟实现的vector中的reserve接口中，使用memcpy进行的拷贝,上面的代码会有什么问题吗？

如果拷贝的是自定义类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。

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

3.动态二维数组理解

vector> vv(n);

完成元素填充后，如下图：