#include<iostream>
#include<string>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
#include<algorithm>//包含所有算法的头文件,例如：sort
#include<functional>//排降序的时候用到
using namespace std;
namespace wwx2
{
  template<class T>
  class my_vector
  {
  public://可以看出上述是把T给直接定义成了一个value_type，然后使用value_type定义了const指针和普通指针（所以本质上：都只是T类型而已）
    typedef T* iterator;//有普通版本的迭代器，此时无论是因为模仿STL还是真的会用到，我们都应该要给一个const类型的迭代器
    typedef const T* const_iterator;
    typedef T& value_type;
    typedef size_t size_type;
    my_vector()
      :_start(nullptr), _finish(nullptr), _end_of_storage(nullptr)//初始化列表初始化
    {}
    my_vector(size_type n, const T& val = T()) //和下述的那个resize同理（使用T匿名对象调用默认构造函数，然后增长匿名对象的生命周期）
      : _start(nullptr), _finish(nullptr), _end_of_storage(nullptr)
    {//所以无论这个类是什么类型，在初始化的时候，我们就是给给它的默认构造就行了
      reserve(n);
      for (size_type i = 0; i < n; ++i)
      {
        push_back(val);
      }
    }
    //此处可以添加一个上述构造函数的int重载版本（省略）
    //使用迭代器区间的一个构造函数（实现了这个函数，此时就会导致下面的那个调用构造函数初始化时，不知道调用那个了，因为此时有两个构造函数），就会导致类型不匹配问题，因为使用迭代器的构造函数，是要求传指针参数的，不可以是整形参数，所以需要改进一下（萝卜青菜区分开来）
    template <class InputIterator>//此时就是一个模板类中有模板函数的写法（本质上是因为迭代器的多样性，不可以把迭代器的类型给写死，要是可变的，所以就使用模板的方式）
    my_vector(InputIterator first, InputIterator last)//就是一个允许类模板的成员函数是一个函数模板
      : _start(nullptr), _finish(nullptr), _end_of_storage(nullptr)
    {
      while (first != last)//迭代器区间：[first,last)
      {
        push_back(*first);
        ++first;
      }
    }
    //上面的两个构造函数对比，如果，下面传上来的参数是两个整形，那么此时因为第一个构造函数的第一个参数是一个无符号数（所以此时需要进行类型的转换）
    //而第二个构造函数的两个参数由于都是指针，所以就可以直接接收，不需要什么类型转换（所以第二个构造函数就是下述传参更爱吃的萝卜）
    //所以如果是两个整形使用了第二个构造函数，那么此时就会导致对整形就行解引用的情况发生，所以就有问题了
    //这个位置还可以加一个给拷贝构造使用的构造函数（如果没有这个拷贝构造函数，而是去调用构造函数的话，这边就会导致经典的浅拷贝问题）
    //my_vector(const my_vector<T>& v)//因为调用拷贝构造的时候，传参传上来的是一个vector的对象，所以这边的参数也要写成vector，不可以像上述一样写成别的类型
    //{//因为上述已经有了一个有缺省参数的构造函数，所以这里不需要再给（总的来说，还是拷贝构造的特性）
    //  reserve(v.capacity());//深拷贝，不然就会导致同一块空间析构两次
    //  for (auto e : v)
    //  {
    //    push_back(e);//这个是因为复用了reserve和push_back（不传统）
    //  }
    //}
    //my_vector(const my_vector<T>& v)//传统一些的深拷贝写法
    //{
    //  reserve(v.capacity());
    //  memcpy(_start, v._start, sizeof(T) * v.size());//这步需要仔细研究一下（本质还是那个道理，反正三指针问题一定要给它搞定）
    //  _finish = _start + v.size();//这边因为_finish是由数据个数决定的，所以新开辟的空间之中有多少个数据是会改变的，所以这边的_finish是需要自己更新一下的，不可以依靠reserve中的_finish（但是reserve中的容量是可以使用的，因为开辟空间的大小是不会改变的）
    //}
    my_vector(const my_vector<T>& v)//最传统的深拷贝写法
    {
      _start = new T[v.capacity()];
      //memcpy(_start, v._start, sizeof(T) * size());//所以为了解决深深拷贝的问题，此时就不可以使用memcpy函数，而是去循环调用赋值（因为赋值运算符本质上就是深拷贝实现的）
      for (size_type i = 0; i < v.size(); ++i)//调用赋值运算符，然后通过复制运算符再去调用拷贝构造
      { 
        _start[i] = v._start[i];//此时这样写，我们就解决了深拷贝中还要深拷贝的问题（本质：就是构造函数中嵌套构造函数）
      }//并且因为按照上述那样写，对内置类型并没有影响，因为复制对内置类型来说也是可以用的（赋值重载本来就是六大默认函数之一，编译器会自己调用）
      _finish = _start + v.size();
      _end_of_storage = _start + v.capacity();//reserve是会处理容量的，所以没有使用reserve的时候，就要自己把容量的大小给处理一下
    }
    ~my_vector()
    {
      delete[] _start;
      _start = _finish = _end_of_storage = nullptr;
    }
    iterator begin()
    {
      return _start;//通过临时变量返回，就是类型传值返回
    }
    iterator end()
    {
      return _finish;//同理
    }
    const_iterator begin()const
    {
      return _start;
    }
    const_iterator end()const
    {
      return _finish;
    }
    size_type capacity()const//像这种函数一定要记得加上我们的const
    {
      return _end_of_storage - _start;
    }
    size_type size()const
    {
      return _finish - _start;
    }
    void resize(size_type n, T val = T())//实现了reserve，此时resize复用就行，只是初始化的细节注意一下和size的大小注意一下就行 (所以此时我们就需要多给一个缺省参数，来进行默认的初始化新开辟的空间)，就是防止你没有给第二个参数，只给了第一个参数，那此时我也可以把空间初始化
    {//上面那个缺省值的初始化是非常的神奇的（目的：因为此时的vector是一个泛型编程，是没有具体类型的，所以不可以用0来初始化，所以就要用一个模板参数，然后就是通过一个匿名对象的方式去调用默认构造函数）
      if (n < size())//这个不是缩容（这个属于删除数据，因为size是和数据紧紧挂钩的）
      {
        _finish = _start + n;//这个条件在尾插的时候，扩容，是不可能存在缩容删除数据的（唯一可能的就是我们直接调用这个函数，然后进行传参的时候，只有这种情况才有可能导致删除）
      }
      else
      {
        if (n > capacity()) //这个条件就是传说中的只有你比我小，我才扩容 
        {
          reserve(n);//开空间
        }
        while (_finish != _start + n)//加 初始化
        {
          *_finish = val;//此时已经有空间了，所以就不需要使用定位new的方法，直接赋值就行
          ++_finish;
        }
      }
    }
    value_type operator[](size_type pos)//并且此时返回的是一个引用，就是返回别名，目的：节省构造，防止临时变量的常属性
    {
      assert(pos < size());
      return _start[pos];//就是返回这个pos位置在_statr中的那个下标位置（因为此时是指针，所以准确的来说，应该是一个地址位置）
    }
    const value_type operator[](size_type pos)const//就是多重载一个const类型的，给给const对象使用（萝卜青菜给有所爱）
    {
      assert(pos < size());
      return _start[pos];
    }
    void reserve(size_type n)
    {
      //这边肯定是要涉及深浅拷贝问题的(并且为了防止缩容问题，这边还要进行判断)
      if (n > capacity())
      {
        //使用下面调换两个指针的顺序是可以解决的，但是不是很好，所以我们这边直接先把size()的值给接收起来就行
        size_type sz = size();//这样直接使用sz就行了，不需要再使用size(),也就是不需要再考虑finish和start的位置（随便它去变，跟我都没关系）
        iterator tmp = new T[n];//此时这里不需要考虑加1的问题（只有像string这种，需要存一个\0的这种，我们才需要多开一个空间给给它使用）
        if (_start != nullptr)//此时的new是不需要想malloc一样就行开辟成功和失败的判断的，这个只是为了单纯判断一下_start中是否有数据
        {
        //  memcpy(tmp, _start, sizeof(T) * size());//由于自定义类型不适用，所以改进一下
          for (size_type i = 0; i < sz; ++i)//深深拷贝的专业写法，间接多调用一次拷贝构造
          {
            tmp[i] = _start[i];
          }
          delete[] _start;//这个就是经典的防止空间太大太小问题，直接开空间，然后拷贝，然后直接把原空间给删除
        }
        //_start = tmp;//注意：因为此时是重新开空间，释放旧空间，所以此时的tmp就是我们的start
        //注意：此时下述的size()是不会因为finish和start的地址改变而改变的 (不会因为重复调用而改变)，一直都是同一个值，也就导致可以直接使用tmp+size()
        //_finish = tmp + size(); //如果此时是先把tmp给给_start，然后再加加size(),此时就会导致finish还是0，而start已经是tmp，然后又因为size就是finish-start，就会导致size是一个负值，也就是-start，然后再用start+size，那么刚好就是0，最后赋值给finish，此时finish就还是0，所以就会导致后面push_back的时候，对空指针解引用的问题，所以此时为了解决这个问题，此时就不敢直接先给给start
        _start = tmp;//先给给finish，再给给start就行，很好的解决finish为空的问题
        _finish = tmp + sz;//提前记录size的好处
        _end_of_storage = tmp + n;//此时的这个是通过tmp指针的首地址，然后加上16个字节，就是首地址向后走走16个字节，得到的就是此时的容量
      }
    }
    void push_back(const T& x)
    {//因为使用的是模板类，所以这里的参数类型都是直接给一个T参数类型就可以了
      //从刚刚的STL源码中，我们可以发现的是，它的push_back使用的是内存池开空间的形式（就是定义new加定义构造）
      //我们这里使用不了，我们就直接使用正常的形式就行（如果想要使用的话，就要在定义模板参数的位置给一个内存池的参数）
      if (_finish == _end_of_storage)
      {
        reserve(capacity() == 0 ? 4 : capacity() * 2);//此时的reserve函数中使用的是赋值运算符重载而不是memcpy，可以放心大胆的使用
      }
      *_finish = x;//这步就是尾插的经典步骤，上述的判断只是为了防止空间不足而已（但是由于我们的_end是一个原生指针，所以这里想要直接在尾部赋值，就需要对这个尾部指针进行解引用）
      ++_finish;
    }
    void pop_back()
    {
      assert(!empty());//切记assert给的是真
      --_finish;//这种如果直接用，不检查的话，就会导致删多了的话有越界问题（并且因为此时是迭代器的写法，地址问题），就会导致循环找地址，然后就导致无限打印地址，直到地址匹配到
    }
    iterator insert(iterator pos, const T& val)
    {
      assert(pos >= _start);
      assert(pos <= _finish);//还是那个道理，assert中的条件是真条件
      //并且由于这边，我们使用了_finish这个位置，就会导致，如果容量刚好等于_finish的时候，越界，所以这个位置也要进行一个容量的检查
      if (_finish == _end_of_storage)
      {
        size_type len = pos - _start;//先记录（len的作用就是解决迭代器失效问题，目的：更新pos指针）
        reserve(capacity() == 0 ? 4 : capacity() * 2);
        pos = _start + len;//扩容后再更新（解决迭代器失效问题）
      }
      iterator end = _finish - 1;
      while (end >= pos)//此时因为pos的类型是地址，所以不存在-1变成无符号（size_t），所以不存在死循环，没有问题
      {
        *(end + 1) = *end;//此时的意思就是把最后一个数据赋值给0，然后把刚刚那个位置腾出来，然后循环
        --end;
      }
      *pos = val;
      ++_finish;
      return pos;
    }
    iterator erase(iterator pos)
    {
      assert(pos >= _start);
      assert(pos < _finish);
      iterator start = pos + 1;
      while (start != _finish)
      {
        *(start - 1) = *start;
        ++start;
      }
      --_finish;
      return pos;//这个位置不敢给成start，因为本质就是为了更新pos
    }
    bool empty()
    {
      return _start == _finish;//当_finish--到_start的时候，就是空，就是不允许的
    }
  private:
    iterator _start;//因为STL源码中是直接使用三个原生指针，所以这边我们模仿它，我们也直接使用三个原生指针就行
    iterator _finish;
    iterator _end_of_storage;
/*    iterator _start = nullptr;
    iterator _finish = nullptr;
    iterator _end_of_storage = nullptr;*///这样写就可以不需要在构造函数的初始化列表位置写初始化了，因为到时候他自己会调用这下面的缺省参数
  };
  void test_my_vector1()
  {
    wwx2::my_vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);
    for (size_t i = 0; i < v.size(); ++i)
    {
      cout << v[i] << " ";
    }
    cout << endl;
    my_vector<int>::iterator it = v.begin();//所以本质，我发现，使用三指针的写法，好像就是为了可以更好的使用迭代器（因为迭代器的本质就是地址的加加减减，前提：地址要连续）
    while (it != v.end())//不连续就会导致迭代器失效问题
    {
      cout << *it << " ";
      ++it;
    }
    cout << endl;
    for (auto e : v)//有了迭代器，就有迭代器的小儿子范围for
    {
      cout << e << " ";
    }
    cout << endl;
  }
  void test_my_vector2()
  {
    wwx2::my_vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);
    v.pop_back();
    v.pop_back();
    my_vector<int>::iterator it = v.begin();
    my_vector<int>::const_iterator cit = v.begin();//反正就是萝卜青菜给有所爱，数据类型是什么就调用什么，不怕没有，想要什么就有什么
    while (it != v.end())
    {
      cout << *it << " ";
      ++it;
    }
    cout << endl;
  }
  template<class T>
  void Function()
  { 
    T x = T();//这个就直接用一个int类型来辅助理解就行（int x = int();） 可以看出此时的int();就是我们之前学的匿名对象；其中int 空表示的就是匿名对象，而int()后面的括号其实表示的是，此时拿着这个int空，匿名对象去调用某一个函数，()括号中存放的本就应该是你要调用的这个函数需要的参数
    cout << x << endl;//总而言之：目的就是为了让任意类型都可以调用默认构造，然后任意类型都可以初始化
  }
  void test_my_vector3()
  {
    //int i = int();//这个的意思就是：使用int()，匿名对象，然后去调用构造函数，然后延长匿名对象的声明周期（把它给给新的对象）
    //int j = int(1);//支持这种写法，本质上还是为了支持模板可以使用（也就是上述resize的缺省参数的写法；很好的解决模板初始化问题）
    //int* p = int*();//指针类型不支持直接把匿名对象给给指针类型
    Function<int>();
    Function<int*>();
    Function<double>();
  }
  void test_my_vector4()
  {
    wwx2::my_vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);
    cout << v.size() << endl;
    cout << v.capacity() << endl;
    v.resize(10);
    for (auto e : v)
    {
      cout << e << " ";
    }
    cout << endl;
  }
  void test_my_vector5()
  {
    wwx2::my_vector<int> v;
    v.push_back(1);//切记push_back也是会调用扩容函数的
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);//此时就很神奇的会涉及到，insert是否扩容问题，如果数据是在push_back的过程，insert就不涉及扩容，如果，insert涉及扩容，那么此时就有迭代器失效的问题，本质就是地址不连续
    //v.insert(3, 30);//聪明的我，居然写成了这样，真的是函数都调不明白啊（但是也刚刚好，可以引出我们的find函数）
    //当然此时也不一定一定要使用find，因为此时可以直接使用迭代器（充分表明我的不聪明）
    v.insert(v.begin(), 0);
    v.insert(v.end(), 6);
    v.insert(v.begin() + 3, 30);//充分表明迭代器是真的好用（促进我们通过变量看地址的好习惯）
    auto pos = find(v.begin(), v.end(), 3);//此时就是把我的迭代器区间传给了find函数，这样就可以使用find函数在迭代器区间中寻找3这个元素
    if (pos != v.end())//这里这样写的目的：主要是为了防止越界
    {
      pos = v.insert(pos, 30);//像这种一直插一直插这种，就会导致一个问题（经典的迭代器失效问题），本质就是：地址不连续了
    }//并且此时如果上述这样写，那么pos在内存中的位置是不会改变的，但是由于insert因为内存不足开空间，导致start和finish的位置发生了改变，间接导致begin和end（迭代器）发生了改变，导致迭代器失效
    (*pos)++;//意思就是：拿更新后的pos地址中的元素加加一下（但是本质上是想要在，3的地方加加，最后会变成在30的地方加加），原因就是pos指向的那个地址是不变（但是地址中的数据在挪动），并且此时因为insert中的pos是个形参，所以不会影响我们外部的pos，所以此时最好使用返回值，直接把pos返回给我们
    //并且此时由于使用引用返回需要有临时变量（常属性），所以不推荐使用，所以这边，我们是通过返回值的方式解决这个问题的
    //总：pos失效后，我们都不推荐使用(*pos)++;所以不敢这样写
    for (auto e : v)//迭代器一失效（也就是begin和end的地址发生了改变），那么此时就会导致pos地址虽然不改变（但是它指向的空间发生了改变（从原来的begin和end的地址变成了一块未知的地址（因为begin和end已经因为扩容拥有了新地址，并且把原来的地址给释放了））），所以pos指向的地址就是一个未知地址，此时pos指针就是一个野指针
    {//总：开空间之后，导致pos指向的迭代器地址被释放，导致野指针问题（这也就是第一种经典的迭代器失效问题）
      cout << e << " ";//所以明白了原理之后，此时的解决方法就是：更新一下pos指针指向的空间（依据pos和start的相对位置不改变来更新）
    } 
    cout << endl;
  }
  void test_my_vector6()
  {
    wwx2::my_vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4); 
    v.push_back(5);
    auto pos = find(v.begin(), v.end(), 2);
    if (pos != v.end())
    {
      v.erase(pos);
    }
    (*pos)++;//此时这个不是解引用的意思，可以算是对*这个运算符重载的意思（本质上*的运算符重载就是在获取一下我想要的功能或者是数据）
    for (auto e : v)//并且此时这种删除之后再访问的方式是很不好的，因为如果按照erase代码来说，删除最后一个及时把finish的位置往前挪动一个，此时如果再去访问刚刚4的pos位置，就会导致对一个空地址解引用，此时就出问题了
    {               //所以总的来说：删除数据后，是不允许进行数据访问的（并且此时数据删除也是伴随着迭代器失效的问题的），因为位置关系发生了改变，也就是导致地址不连续（迭代器失效的本质）
      cout << e << " ";
    }
    cout << endl;
  }
  void test_my_vector7()
  {
    wwx2::my_vector<int> v;
    v.push_back(10);
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);
    v.push_back(50);
    for (auto e : v)
    {
      cout << e << " ";
    }
    cout << endl;
    //此时要求删除所有的偶数
    //std::vector<int>::iterator it = v.begin();
    wwx2::my_vector<int>::iterator it = v.begin();
    while (it != v.end())
    {
      if (*it % 2 == 0)
      {
        it = v.erase(it);//此时因为我们已经通过返回值可以直接拿到it的位置了，所以就不需要每次都++，因为数据覆盖之后，我的it就已经是被覆盖成了新的数据，此时只要再判断一下这个数据是不是偶数就行
      }
      else//因为可以连续拿到it位置的数据，所以it++只有在不是奇数的时候需要使用
      {
        ++it;
      }
    }
    for (auto e : v)
    {
      cout << e << " ";
    }
    cout << endl;
  }
  void test_my_vector8()
  {
    //wwx2::my_vector<int> v(10, 5);
    //wwx2::my_vector<int> v(10u, 5);//解决方案一：在整形后面加个u，表示无符号的意思，本质就是让它去找那个无符号的参数匹配
    wwx2::my_vector<int> v(10u, 5);//解决方案二：就是把上面那个函数提供一个int类型的重载函数（这个似乎有点傻傻的样子）
    //迭代器构造函数的正确使用方法：
    wwx2::my_vector<int> v2(v.begin(), v.end());
    //wwx2::my_vector<int> v(++v.begin(), --v.end());//此时这个一开始报错的原因（也就是不让我加加减减的原因）就是：涉及临时变量（常属性问题）
        //因为我们一开始的时候写的begin和end函数使用的是传值返回（解决方法就是：使用传引用返回，但是没什么必要（避免风险，导致first和last被间接改变））
    wwx2::my_vector<int> v3(v.begin() + 1, v.end() - 1);//避免临时变量常属性问题 ，先返回，返回之后再加加减减
    //因为我们的构造函数是使用随机迭代器实现的，所以是可以接收任何类型的迭代器的，例如：
    std::string s1("hello world");
    wwx2::my_vector<int> v4(s1.begin(), s1.end());//所以传什么类型的迭代器都是没什么问题的（迭代器就是牛），只要类型匹配就行（可以强转）
    //或者可以这样玩（本质就是在玩地址）
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };//随机迭代器，爱咋玩咋玩
    wwx2::my_vector<int> v5(arr, arr + 10);
    for (auto e : v)
    {
      cout << e << " ";
    }
    cout << endl;
    for (auto e : v2)
    {
      cout << e << " ";
    }
    cout << endl;
    for (auto e : v3)
    {
      cout << e << " ";
    }
    cout << endl;
    for (auto e : v4)
    {
      cout << e << " ";
    }
    cout << endl;
    for (auto e : v5)
    {
      cout << e << " ";
    }
    cout << endl;
  }
  void test_my_vector9()
  {
    int arr[] = { 0,10,4,3,2,6,9,8,1,7,5 };
    my_vector<int> v(arr, arr + 10);
    for (auto e : v)
    {
      cout << e << " ";
    }
    cout << endl;
    cout << "排序之后的情况:" << endl;
    sort(v.begin(), v.end());//总的来说：就是算法库里面存在着一个迭代器形式的sort函数（反正迭代器就是神），本质：指针（地址）yyds
    for (auto e : v)
    {
      cout << e << " ";
    }
    cout << endl;
    sort(arr, arr + sizeof(arr) / sizeof(arr[0]));//总归有了迭代器，函数变得更加的好用了，更加方便了（可爱！），并且此时是 默认是升序（降序需要控制一下）
    for (auto e : v)
    {
      cout << e << " ";
    }
    //排降序的写法
    cout << "降序：" << endl;
    //greater<int> g;//这个东西叫仿函数（具体以后学习）
    //sort(arr, arr + sizeof(arr) / sizeof(arr[0]),g);//想要排降序，就需要多传一个参数，具体原理不了解，先看看怎么使用就行
    //这种写法，很适合直接写成匿名对象的形式
    sort(arr, arr + sizeof(arr) / sizeof(arr[0]), greater<int>());
    for (auto e : v)
    {
      cout << e << " ";
    }
  }
  //此时这边有一个很重要的知识点：我们使用sort，排序的是我们自己的容器（vector），原理是因为我们包含了头文件，去调用了别的头文件中的函数，这里好像埋了一个炸弹没有解决
  void test_my_vector10()
  {
    my_vector<int> v(10u, 5);//调用自己实现的构造函数
    for (auto e : v)
    {
      cout << e << " ";
    }
    cout << endl;
    my_vector<int> v1(v);//调用拷贝构造(本质还是在调用构造函数，只是此时是通过this指针，用v这个已经初始化的对象去初始化v1这个对象而已)，注意和赋值的区别，区别就是赋值是两个都已经实例化的对象，而拷贝构造是一个已经实例化，一个还没有
    for (auto e : v1)
    {
      cout << e << " ";
    }
    cout << endl;
    my_vector<std::string> v2(3, "1111111111111111");
    for (auto e : v2)
    {
      cout << e << " ";
    }
    cout << endl;
    my_vector<std::string> v3(v2);//这句代码的意思就是使用一个string类的vector模板类来拷贝构造另一个新对象（v2）
    //此时因为使用v2去初始化v3的时候回去调用reserve函数（防止空间太大太小问题），都是直接开空间，然后memcpy，最后delete原空间
    //这样写的好处有两点：一个是解决深浅拷贝问题（前提是内置类型），一个就是解决空间浪费和不足问题
    //但是此时如上述一样，我们不再是内置类型，而是自定义类型，并且此时这个自定义类型中也涉及到了深浅拷贝问题（就是也有一块空间）
    //那么此时就是变成是深深拷贝问题，需要进行两次的开辟空间
    //所以如上述我们这样写，只调用了一次reserve(new)函数，那么就会导致， 原本应该有两次的深拷贝变成了一次，就又会导致同一块空间被析构两次的问题了
    for (auto e : v3)
    {
      cout << e << " ";
    }
    cout << endl;
    //所以此时我们按照这个写法，我们就可以发现，我们的程序因为同一块空间释放了两次而导致崩溃了
    //本质的原因：就是我们使用了memcpy，它只会进行浅拷贝，把原空间中的地址拷贝到新空间中，不会进行深拷贝
    //所以解决的方法就是不能使用memcpy，而是自己再去实现一个深拷贝出来（因为memcpy是库里面规定的写法（不会进行深拷贝））
    //所以memcpy只有在进行内置类型深拷贝的时候可以使用，而在拷贝自定义类型的时候，最好就不使用memcpy函数
    //解决原理是上述所说的那样，但是因为我们已经实现了一个深拷贝了，模板类中的自定义类型的数据的深拷贝问题，我们是摸不到的，所以，此时我们并不能自己去实现深拷贝，（例:string类中的私有对象我们是访问不了的）
    //此时根据这个拷贝构造的问题，此时我们就还可以发现，我们在扩容的时候，复制数据的时候，使用的也是memcpy函数
    //所以扩容（使用memcpy）对于普通的内置类型处理是没有什么问题的，但是如果是自定义类型，那么此时就连扩容本质上也是有问题的（因为扩容也是需要把旧空间中的数据拷贝到新空间的）
    // 并且由于扩容的时候，会把原来的空间释放掉（那么就会导致你的空间中所有的自定义类型上的指针类型，都是野指针）
    //所以同理，无论是扩容还是构造函数，只要需要对自定义类型进行拷贝，那么此时就不仅要涉及到外部空间的深拷贝，还要注意到空间内的数据的深拷贝问题
    //所以解决方法和拷贝构造函数是一样的，就是使用赋值运算符重载，然后通过它间接的再去调用一次拷贝构造（例:string类中的私有对象我们是访问不了的）
    //但是此时由于不是所有的类都会去重载赋值，string有重载赋值，但是vector类却没有重载赋值，所以此时导致vector类中类此时就算是使用了赋值运算符重载
    //也不可以进行深深拷贝问题，还是解决不了问题，还是一个深层次的浅拷贝问题，所以还是会崩溃（string可以，但vector类不可以）
    //本质上还是没有两次的深拷贝构造函数的实现（没有重载赋值运算符）
    //并且此时我们是要注意到，我们的构造函数是可以使用现代化的写法的
  }
}
int main()
{
  wwx::vector<int>::iterator it;
  //cout << typeid(it).name() << endl;//typeid函数就是为了获得这个变量的类型是什么而已
  wwx2::test_my_vector1();//测试尾插
  wwx2::test_my_vector2();//测试尾删
  wwx2::test_my_vector3();//测试匿名对象
  wwx2::test_my_vector4();//测试resize
  wwx2::test_my_vector5();//测试insert和erase（本质：扩容导致迭代器失效问题）
  wwx2::test_my_vector6();//测试插入函数中迭代器失效
  wwx2::test_my_vector7();//测试编译器对erase的控制（std是直接报错（只要删除了数据，就是报错））
    wwx2::test_my_vector8();//测试构造函数
    wwx2::test_my_vector9();//测试随机迭代器
  wwx2::test_my_vector10();//测试深浅拷贝问题
  return 0;
}