#include<stdio.h>
#include<iostream>
#include<assert.h>
#include<string.h>
#include<malloc.h>
#include<algorithm>
using namespace std;
class String
{
public:
  //传统写法
  //String(char *str)
  //  :_str(new char[strlen(str)+1])
  //{
  //  strcpy(_str,str);
  //}
  ~String()
  {
    if(_str)
    {
      delete[] _str ;
    }
  }

  //String(const String& s)
  //{
  //  _str = new char[(strlen(s._str)+1)];
  //  strcpy(_str,s._str);
  //}

  //String& operator=(const String &s)
  //{
  //  //防止自己给自己赋值，会将自己释放掉
  //  if(&s != this)
  //  {
  //    delete[] _str;
  //    _str = new char[(strlen(s._str)+1)];
  //    strcpy(_str,s._str);
  //    return *this;
  //  }
  //}
  //
  //
  //
  //现代写法：简洁
  String(const char *str)
    :_str(new char[strlen(str)+1])
  {
    //'\0'不算到_capacity里
    _size = strlen(str);
    _capacity = _size;
    strcpy(_str,str);
  }
  //拷贝构造
  String(const String& s)
    :_str(NULL)
  {
    String tmp(s._str);
    swap(_str,tmp._str);//内置函数直接可以用
    //调用完函数后，会销毁tmp的空间，但tmp空间为随机值，所以程序会崩溃
    //可将tmp置为NULL,即将_str置为NULL
    _size = tmp._size;
    _capacity = tmp._capacity;
  }

  //1.赋值运算符的重载
  String& operator=(const String& s)
  {
    if(this != &s)
    {
      String tmp(s._str);
      //printf("%s",tmp._str);
      swap(_str,tmp._str);
    }
    return *this;
  }
  
  //2.
  //String &operator=(String s)
  //{
  //  //解决不了自己给自己赋值的问题
  //  //会重新开辟空间有消耗
  //  swap(_str,s._str);
  //  return *this;
  //}
  void Expand(size_t n)
  {
    if(n>_capacity)
    {
      char *newstr = new char[n+1];//+1保存'\0'
      strcpy(newstr,_str);
      delete[] _str;
      _str = newstr;
    }
  }
  void PushBack(char ch)
  {
    if(_size >= _capacity)
    {
      Expand(_capacity *2);
    }
    _str[_size++] = ch;
    _str[_size] = '\0';
  }
  void PushBack(const char* str)
  {
    size_t len = strlen(str);
    if(_size+len > _capacity)
    {
      Expand(_size + len);
    }
    strcpy(_str+_size+1 , str);
    _size += len;
  }

  String operator+(const char* str)
  {
    String s(*this);
    s.PushBack(str);

    return s;
  }

  String operator+(char ch)
  {
    String s(*this);
    s.PushBack(ch);

    return s;
  }

  String& operator+=(char ch)
  {
    PushBack(ch);
    return *this;
  }

  String& operator+=(const char *str)
  {
    PushBack(str);
    return *this;
  }
  

  void PushFront(char ch)
  {
    if(_size >= _capacity)
    {
      Expand(_capacity * 2);
    }
    for(int i = _size;i >= 0;i--)
    {
      _str[i+1] = _str[i];
    }
    _str[0] = ch;
  }

  void PushFront(const char* str)
  {
    size_t len = strlen(str);
    if(_size + len >= _capacity)
    {
      Expand(_size + len);
    }
    for(int i = _size;i >= 0; --i)
    {
      _str[i+len] = _str[i];
    }
    //for(int j = 0;j < len;j++)
    //{
    //  _str[j] = str[j];
    //}
    //memcpy(_str,str,len);

    char *p = _str;
    while(*str != '\0')
    {
      *p++ = *str++;
    }
    _size += len;
  }

  void Insert(size_t pos,char ch)
  {

    if(_size + 1 >= _capacity)
    {
      Expand(_capacity * 2);
    }
    //若用int i和size_t pos 相比的话会出现整型提升，int会被提升为size_t
    for(int i = _size;i >= (int)pos; --i)
    {
      _str[i+1] = _str[i];
    }
    _str[pos] = ch;
    _size++;
  }

  void Insert(size_t pos,const char* str)
  {
    size_t len = strlen(str);
    if(_size + len >= _capacity)
    {
      Expand(_size + len);
    }
    for(int i = _size;i >= (int)pos;--i)
    {
      _str[i+len] = _str[i];
    }
    
    char *p = _str + pos ;
    while(*str != '\0')
    {
      *p++ = *str++;
    }
    _size += len;
  }

  //删除一个指定位置的元素
  void Erase(size_t pos,size_t len = 1)
  {
    assert(pos < _size && pos > 0);
    if(pos + len >= _size)
    {
      _str[pos] = '\0';
      _size = pos;
    }
    else 
    {
      strcpy(_str+pos , _str+pos+len);
      _size -= len;
    }
  }


  bool operator>(const char* str)const
  {
    size_t size2 = strlen(str);
    size_t size1 = strlen(_str);
    if(size1 > size2)
    {
      return true;
    }
    if(size1 < size2)
    {
      return false;
    }
    const char *p1 = _str;
    const char *p2 = str;
    while(*p1 && *p2)
    {
      if(*p1 > *p2)
      {
        return false;
      }
      else if(*p1 < *p2)
      {
        return true;
      }
      else 
      {
        ++p1;
        ++p2;
      }
    }
    //此时只有一种情况
    return false;
  }
  bool operator>=(const char* str)
  {
    if(_str > str || _str == str)
    {
      return true;
    }
    return false;
  }
  bool operator<(const char* str)
  {
    size_t size2 = strlen(str);
    size_t size1 = strlen(_str);
    if(size1 > size2)
    {
      return true;
    }
    if(size1 < size2)
    {
      return false;
    }
    const char *p1 = _str;
    const char *p2 = str;
    while(*p1 && *p2)
    {
      if(*p1 > *p2)
      {
        return false;
      }
      else if(*p1 < *p2)
      {
        return true;
      }
      else 
      {
        ++p1;
        ++p2;
      }
    }
    return false;
  }
  bool operator!=(const char* str);
  bool operator==(const char* str)
  {
    char *p1 = _str;
    const char *p2 = str;
    while(*p1++ == *p2++ && *p1 != '\0'&&*p2 != '\0')
    {
      ;
    }
    if(*p1 =='\0' && *p2 =='\0')
    {
      return true;
    }
    return false;
  }
  bool operator<=(const char* str)
  {
    if(_str < str || _str == str)
    {
      return true;
    }
    return false;
  }
  //虽然能读到，但是不能改
  const char& operator[](size_t pos)const
  {
    assert(pos <= _size &&pos > 0);
    return _str[pos];
  }
  //从pos位置查找ch，找到了返回位置，没找到返回-1
  size_t Find(char ch,size_t pos = 0);
  //从pos位置查找str字符串
  size_t Find(const char *str,size_t pos = 0);
  //将当前字符串中的字符子串替换成str2
  void Replace(const char *str1,const char *str2);



public:
  char* _str;
  size_t _size;
  size_t _capacity;
};

void test()
{
  String s1("zhao");
  String s2("man");
  //String s3("man");
  s2 = s1;
  //s2.PushBack("!!!");
  s2.PushFront("!!!");
  s2.Insert(1,"lalala");
  s2.Erase(1,4);
  printf("%s\n",s2._str);
  bool a = s1._str <= s2._str;
  printf("%d\n",a);

  //printf("%s\n",s3._str);

  return;
}


int main()
{
  test();
  return 0;
}