string类的模拟实现

模拟实现string类，最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数,

大家看下以 下string类的实现是否有问题？

class String
{
public:
     /*String()
     :_str(new char[1])
     {*_str = '\0';}
     */
    
     String(const char* str = "")
     {
         
         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 world!!!");
     String s2(s1);
}

说明：上述String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。

浅拷贝

浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

深拷贝

深拷贝：如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供 。

class String
{
public:
     String(const char* str = "")
     {
         // 构造String类对象时，如果传递nullptr指针，可以认为程序非
         if (nullptr == str)
         {
             assert(false);
             return;
         }
         _str = new char[strlen(str) + 1];
         strcpy(_str, str);
     }
     String(const String& s)
     : _str(new char[strlen(s._str) + 1])
     {
         strcpy(_str, s._str);
     }
     String& operator=(const String& s)
     {
         if (this != &s)
         {
             char* pStr = new char[strlen(s._str) + 1];
             strcpy(pStr, s._str);
             delete[] _str;
             _str = pStr;
         }
         return *this;
     }
     ~String()
     {
         if (_str)
         {
         delete[] _str;
         _str = nullptr;
         }
     }
private:
     char* _str;
};