#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
using namespace std;
namespace wwx
{
  template<class T>
  class vector
  {
  public:
    typedef T value_type;
    typedef value_type* iterator;
    typedef const value_type* const_iterator;
    typedef size_t size_type;
    iterator begin()
    {
      return start;
    }
    iterator end()
    {
      return finish;
    }
    vector()
      :start(0), finish(0), end_of_storage(0)
    {};
    size_type size()const
    {
      return size_type(end() - begin());
    }
    size_type capacity()const
    {
      return size_type(end_of_storage - begin());
    }
  private:
    iterator start;
    iterator finish;
    iterator end_of_storage;
  };
}

  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>();
  }

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)//初始化列表初始化
    {}
    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());
          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);
      }
      *_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;
    }
    void erase(iterator pos)
    {
      assert(pos >= _start);
      assert(pos < _finish);
      iterator start = pos + 1;
      while (start != _finish)
      {
        *(start - 1) = *start;
        ++start;
      }
      --_finish;
    }
    bool empty()
    {
      return _start == _finish;//当_finish--到_start的时候，就是空，就是不允许的
    }
  private:
    iterator _start;//因为STL源码中是直接使用三个原生指针，所以这边我们模仿它，我们也直接使用三个原生指针就行
    iterator _finish;
    iterator _end_of_storage;
  };
}

  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;
  }
int main()
{
  wwx::vector<int>::iterator it;
  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();
  return 0;
}