C++:string类！

void Teststring()
{
    string s1; // 构造空的string类对象s1
    string s2("hello bit"); // 用C格式字符串构造string类对象s2
    string s3(s2); // 拷贝构造s3
}

void test_string7()
{
  string s("hello world");
  cout << s.capacity() << endl;//最开始capacity是15 ,后面还有一个'\0'
  cout << s.size() << endl;//11
  //s.resize(13);//不给实际值，会将多出的补'\0'
  //cout << s << endl;
  //cout << s.size() << endl;
  //s.resize(13,'x');//原有数据不变，后面补'x'
  s.resize(20,'x');//大于原有的capacity会扩容
  cout << s << endl;
  cout << s.size() << endl;
  cout << s.capacity() << endl;
  s.resize(5);//小于原有的size,会删除后面的数据
  cout << s << endl;
  cout << s.size() << endl;
  cout << s.capacity() << endl;
  //at 与 operator[] 类似，但at越界只会抛异常，【】会断言终止程序
  //s.at(0);
  //s[0];
}

void test_string2()
{
  string s1("hello world");
  string s2 = "hello world";//先构造，再拷贝构造，编译器优化为一步构造。
  //遍历string
  //读
  for (size_t i = 0; i < s1.size(); i++)
  {
    cout << s1[i] << " ";
  }
  cout << endl;
  //写   
  for (size_t i = 0; i < s1.size(); i++)
  {
    s1[i]++;
  }
  cout << s1 << endl;
  //迭代器  行为上像指针
  string::iterator it = s2.begin();
  //s2.end()是指向有效字符的下一位，'\0'
  //while(it < s2.end()) //这里可以，但不建议。因为这里物理空间是连续的，链表等不是连续的
  while (it != s2.end())
  {
    //读
    cout << *it << " ";
    it++;
  }
  cout << endl;
  it = s2.begin();
  while (it != s2.end())
  {
    //写
    *it = 'a';
    it++;
  }
  cout << s2 << endl;
}

void test_string11()
{
  string s1("test.c.tar.zip");
  //size_t i = s1.find('.');
  //cout << i << endl;
  size_t i = s1.rfind('.');
  cout << i << endl;
  string s2 = s1.substr(i);//取后面的数据
  cout << s2 << endl;
  string s3("https://legacy.cplusplus.com/reference/string/string/rfind/");
  //取协议
  //域名
  //资源名
  string sub1, sub2, sub3;
  size_t i1 = s3.find(':');
  if (i1 != string::npos)//没有找到,i1 等于静态成员变量npose
    sub1 = s3.substr(0, i1);
  size_t i2 = s3.find('/', i1 + 3);
  if (i2 != string::npos)
    sub2 = s3.substr(i1+3, i2-i1-3);
  sub3 = s3.substr(i2+1);
  cout << sub1 << endl;
  cout << sub2 << endl;
  cout << sub3 << endl;
}

union _Bxty
{ // storage for small buffer or pointer to larger one
    value_type _Buf[_BUF_SIZE];
    pointer _Ptr;
    char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;

struct _Rep_base
{
    size_type _M_length;
    size_type _M_capacity;
    _Atomic_word _M_refcount;
};

// 为了和标准库区分，此处使用String
class String
{
public:
    /*String()
    :_str(new char[1])
    {*_str = '\0';}
        */
    //String(const char* str = "\0") 错误示范
    //String(const char* str = nullptr) 错误示范
    String(const char* str = "")
    {
        // 构造String类对象时，如果传递nullptr指针，可以认为程序非
        if (nullptr == str)
        {
            assert(false);
            return;
        }
    _str = new char[strlen(str) + 1];
    strcpy(_str, str);
    }
    ~String()
    {
        if (_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }
    private:
    char* _str;
}
// 测试
void TestString() //这里会出现浅拷贝的错误
{
    String s1("hello xlh!!!");
    String s2(s1);
}

class string
  {
  public:
        //构造函数
    string(const char* str = "")//后面会有一个'\0'
      :_size(strlen(str))//初始化列表按成员声明顺序执行
      , _capacity(_size)
      ,_str(new char[strlen(str)+1])
    {
      strcpy(_str, str);
    }
        void swap(string& s)
    {
      std::swap(_str, s._str);
      std::swap(_size, s._size);
      std::swap(_capacity, s._capacity);
    }
        //拷贝构造函数
    //传统写法
    /*string(const string& str)
    {
      _size = str._size;
      _capacity = str._capacity;
      _str = new char[_capacity + 1];
      strcpy(_str, str._str);
    }*/
    string(const string& str)
      :_size(0)
      , _capacity(0)
      ,_str(nullptr)
    {
      string tmp(str._str);//调用构造函数
      swap(tmp);
    }
        //赋值运算符重载
    //传统写法
    //string& operator=(const string& str)
    //{
    //  if(this != &str)
    //  {
    //    /*reserve(str._size);
    //    strcpy(_str, str._str);
    //    _size = str._size;
    //    return *this;*/
    //    char* tmp = new char[str._capacity + 1];
    //    strcpy(tmp, str._str);
    //    delete[] _str;
    //    _str = tmp;
    //    _size = str._size;
    //    _capacity = str._capacity;
    //    return *this;
    //  }
    //}
    //现代写法
    //string& operator=(const string& str)
    //{
    //  if (this != &str)
    //  {
    //    string tmp(str);//调用拷贝构造
    //    //string tmp(str._str);//也可以调用构造函数
    //    //this->swap(tmp);
    //    swap(tmp);//tmp最后会释放原来this的空间
    //  }
    //  return *this;
    //}
    //极致的现代写法
    string& operator=(string tmp)
    {
      swap(tmp);
      return *this;
    }
        //析构函数
    ~string()
    {
      delete[] _str;
      _str = nullptr;
      _size = _capacity = 0;
    }
    private:
    char* _str;
    size_t _size;
    size_t _capacity;
    const static size_t npos;
    //静态成员变量，不走初始化列表，静态成员变量不能给缺省值
    //const 静态 整形 可以
    //const size_t string::npos = -1;//特例
};