#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
#include<assert.h>
using namespace std;
namespace wwx
{
  class String
  {
  public:
    typedef char* iterator;//普通类型迭代器
    typedef const char* const_iterator;//const类型迭代器(注意此时自己是可以修改的，只是解引用后的值是不可以修改的)
    iterator begin()
    {
      return _str;//此时因为String本质上就是一个字符数组，所以_str就是首元素地址，就是第一个字符
    }
    iterator end()
    {
      return _str + _size;//这个就是最后一个字符（前提是要知道第一个字符的位置）
    }
    const_iterator begin()const
    {
      return _str;
    }
    const_iterator end()const
    {
      return _str + _size;
    }
    String(const char* str = " ")//或者写成"\0"，反正这个位置只要可以让strlen算出一个0来就行了（全缺省构造函数）
      : _size(strlen(str))
    {
      _capacity = _size == 0 ? 3 : _size;//_capacity为0第一种解决方法
      _str = new char[_capacity + 1];
      strcpy(_str, str);
    }
    String(const String& s)//注意：拷贝构造也是有初始化列表的（并且要回想起以前有关this指针的知识，此时*this就是s3，str就是s2）
      :_size(s._size)
      ,_capacity(s._capacity)
    {
      //深拷贝（因为使用了指针，或者说因为有自己实现析构函数）
      _str = new char[s._capacity + 1];
      strcpy(_str, s._str);
    }//并且此时要记住，此时的拷贝构造除了利用*this指针以外，还有一个是使用赋值运算符（=）
    String& operator=(const String& s)//区分赋值和拷贝构造，赋值是两个已经存在的对象，而拷贝构造是一个已经初始化的对象去初始化另一个要创建的对象
    {
      if (this != &s)//防止自己给自己赋值
      {
        //_size = s._size;
        //_capacity = s._capacity;
        //delete[]_str;//这种赋值方法，可以很好的避免被赋值空间太大或太小的问题，只是伴随着开空间的消耗而已
        //_str = new char[s._capacity + 1];
        //strcpy(_str, s._str);
        //为了防止空间开辟失败把原来的空间中的数据给破坏，下面的写法就更好
        char* tmp = new char[s._capacity + 1];//解决原理：先开空间，再销毁，再给给
        strcpy(tmp, s._str);
        delete[]_str;
        _str = tmp;//此时因为指针指向的空间，本质是内置类型，所以会自己去调用拷贝构造函数，不需要调用我们自己实现的拷贝构造函数
        _size = s._size;
        _capacity = s._capacity;
      }
      return *this;
    }
    ~String()
    {
      delete[]_str;
      _str = nullptr;
      _size = _capacity = 0;
    }
    const char* c_str()
    {
      return _str;
    }
    char& operator[](size_t pos)//普通类型使用，下面的是给特殊的const类型函数使用
    {
      assert(pos < _size);
      return _str[pos];
    }
    const char& operator[](size_t pos)const//后面位置上给了const前面就一定也要给一个const，因为此时加了const导致返回值的类型也变成了const类型
    {
      assert(pos < _size);
      return _str[pos];
    }
    size_t size()const
    {
      return _size;
    }//运算符重载
    // 所以得出结论，只要是函数内部不进行数据修改的，我们就把const给加上
    bool operator>(const String& s)const
    {
      return strcmp(_str, s._str) > 0;
    }
    bool operator==(const String& s)const
    {
      return strcmp(_str, s._str) == 0;
    }
    bool operator>=(const String& s)const
    {
      return *this > s || *this == s;
      //return *this > s || s == *this;//此时就是简单的把赋值顺序调换一下，该代码就是有问题的，因为此时的s是const类型的，妥妥的权利放大
    }                                  
    bool operator<(const String& s)const
    {
      return !(*this >= s);
    }
    bool operator<=(const String& s)const
    {
      return !(*this > s);
    }
    bool operator!=(const String& s)const
    {
      return !(*this == s);
    }
    void resize(size_t n, char ch = '\0')
    {
      int len = strlen(_str);
      if (_capacity < n)
      {
        reserve(2 * n);
      }
      if (n < _size)
      {
        _size = n;
        _str[_size] = '\0';
        return;
      }
      _size = n;
      for (int i = len; i < _size; i++)
      {
        _str[i] = ch;
      }
      _str[_size] = '\0';
    }
    void reserve(size_t n)//此时的这个n参数表示的就是n需要扩n个空间
    {
      char* tmp = new char[n + 1];//此时为了像上述一样，防止开辟失败，所以先开辟，再赋值（注意：capacity和字符个数的区别，capacity少1）
      strcpy(tmp, _str);//此时就是注意：只要是在类里面的函数都是自带一个this指针的类对象
      delete[]_str;
      _str = tmp;
      _capacity = n;//开空间跟_size是没有关系的，只有插入数据的时候才跟_size有关系
    }
    void push_back(char ch)//注意：有一个this指针，此时就是为了在这个this指针后面插入字符
    {
      if (_size == _capacity)//这种判断==的是需要多少扩多少（所以可以二倍二倍的扩）
      {
        //注意此时要配套使用，不可以使用realloc扩容
        reserve(_capacity == 0 ? 4 : _capacity * 2);
      }
      _str[_size] = ch;//string的本质就是一个字符数组
      ++_size;
      _str[_size] = '\0';//此时就是因为插入字符之后，把原来的\0给搞没了，所以要重新给一个\0，不然就会导致无法计算strlen之类的问题
    }
    void append(const char* str)//注意此时这个函数是用来插入字符串的，不是上述用来插入字符的
    {
      size_t len = strlen(str);
      if (_size + len > _capacity)//此时这个位置表示的就是插入len个字符（插入len个字符，刚好等于capacity可以，但是不可以超过）
      {
        //此时这种直接插入多个，就不可以2倍2倍的扩，需要一次性扩大一点
        reserve(_size + len);
      }
      strcpy(_str + _size, str);//该拷贝，是因为可以直接把原来字符串中的\0给覆盖掉
      //strcat(_str, str);//但是最好不要使用strcat，追加，目的是因为防止原字符串过长，\0不好找，因为strcat只有找到了\0才会进行追加
      _size += len;
      //字符串是不需要处理\0的，因为strcpy会拷贝\0
    }
    String& operator+=(char ch)
    {
      push_back(ch);
      return *this;
    }
    String& operator+=(const char* str)
    {
      append(str);
      return *this;
    }//某个位置插入、某个位置删除
    void insert(size_t pos, char ch)//某个位置插入字符
    {
      assert(pos <= _size);//防止传参的时候越界
      if (_size + 1 > _capacity)//还是因为等于的时候是刚刚好满了，所以不怕，只有大于的时候才需要扩
      {
        reserve(2 * _capacity);
      }
      size_t end = _size;
      while (end >= pos)
      {
        _str[end + 1] = _str[end];
        --end;
      }
      _str[pos] = ch;
      ++_size;
    }
    void insert(size_t pos, const char* str)//某个位置插入字符串
    {
      assert(pos <= _size);
      size_t len = strlen(str);
      if (len == 0)
      {
        return;
      }
      if (_size + len > _capacity)
      {
        reserve(_capacity + len);
      }//扩容完之后就是插入数据
      size_t end = _size + len;
      for (int i = end; i >= pos + len; --i)
      {
        _str[i] = _str[i - len - 1];
      }
      char c = _str[pos + len];
      strcpy(_str + pos, str);
      _str[pos + _size] = c;
      _size += len;
      _str[_size] = '\0';
    }
    void erase(size_t pos, size_t len = npos)
    {
      assert(pos>=0 && pos <= _size);
      size_t end = _size;
      while (end > pos)
      {
        _str[end - 1] = _str[end];
        --end;
      }
      --_size;
    }
  private:
    char* _str;
    size_t _size;
    size_t _capacity;
    static size_t npos;//npos此时给一个静态成员变量，供给大家使用
    //有一个特例，可以不需要在全局定义static，但是只针对于整形,就是加一个const
    //static const size_t npos = -1;
    //static const size_t N = 10;
    //估计是为了可以这样使用：int _arr[N];
  };
  size_t String::npos = -1;
  void Print(const String& s)
  {
    for (size_t i = 0; i < s.size(); ++i)
    {
      cout << s[i] << " ";//此时因为这个函数就是一个const修饰的函数，所以无论在函数内存调用运算符重载，还是别的函数，此时这些函数都需要有const属性，所以导致我们需要实现两个[]运算符重载，一个给普通类型使用，一个给const类型使用
    }
    cout << endl;
    for (auto ch : s)//证明const属性的迭代器（所以需要把迭代器也给弄成两份，一份普通类型，一份const类型）
    {
      cout << ch << " ";
    }
    cout << endl;
  }
  void test_string1()
  {
    String s1;
    String s2("hello world");
    cout << s1.c_str() << endl;
    cout << s2.c_str() << endl;
    for (int i = 0; i < 10; i++)
    {
      s2[i]++;
    }
    String s3(s2);//拷贝构造（经典的指针指向同一块空间问题），涉及深拷贝
    cout << s3.c_str() << endl;
    cout << s2.c_str() << endl;
    s3 = s2;//赋值要注意有自己给自己赋值的时候 s2 = s2;
    cout << s3.c_str() << endl;
    cout << s2.c_str() << endl;
  }
  void test_string2()//验证const修饰的函数需要使用具有const属性的函数
  {
    wwx::String s1("hello world");
    for (size_t i = 0; i < s1.size(); ++i)//注意：此时访问的不是string类中的成员变量，访问的是计算size大小的公有函数
    {
      cout << ++s1[i] << " ";
    }
    cout << endl;
    Print(s1);
  }
  void test_string3()//验证正向迭代器（反向迭代器先不学）
  {
    String s1("gdkkn vnqkc");
    String::iterator it = s1.begin();//普通it类型
    String::const_iterator it2 = s1.begin();//const类型的it
    while (it != s1.end())
    {
      cout << ++(*it) << " ";//指针不仅可以读，而且可以写
      ++it;//虽然被const修饰，但是自己是可以修改的，例：++it是可以的++(*it)就是不可以的（总：自己可以修改，只是指向的内容不可以修改而已）
      ++it2;
      //cout << ++(*it2) << " ";//const迭代器指向的内容不允许被修改
    }
    cout << endl;
    for (auto ch : s1)//很好的证明了，范围for就是使用迭代器实现的（傻白甜）
    {
      cout << ch << " ";
    }
    cout << endl;
  }
  void test_string4()//验证运算符重载
  {
    string s1("hello world");
    string s2("hello world");
    string s3("xxxxxxxxxxx");
    //比大小，此时比的是ASCII码值
    cout << (s1 < s3) << endl;//涉及运算符的优先级,所以要加上()
    cout << (s1 == s3) << endl;
    cout << (s1 == s2) << endl;
    cout << (s1 >= s3) << endl;
    cout << (s1 > s3) << endl;
    cout << (s1 != s2) << endl;
  }
  void test_string5()//验证字符和字符串追加
  {
    string s1("hello world");
    s1.push_back(' ');//反正就是注意使用this指针就行（因为this指针代表的就是s1对象）
    cout << s1.c_str() << endl;
    s1.append("xxxxxxxxxxxxxxxx");
    cout << s1.c_str() << endl;
    s1 += "aaaaaaaaaaaaaaaaaa";
    cout << s1.c_str() << endl;
  }
  void test_string6()
  {
    String s1("hello world");
    s1.insert(6, 'm');
    s1.insert(7, 'y');
    s1.insert(8, ' ');//搞定了中间插入，此时要防止是在最头上插入等问题
    cout << s1.c_str() << endl;
    s1.insert(5, "bit");
    cout << s1.c_str() << endl;
    s1.erase(5, 3);
    cout << s1.c_str() << endl;
  }
}