【C++】深拷贝/浅拷贝

经典的string类问题

在面试中，面试官总喜欢让我们来模拟实现string类，最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。以 下string类的实现是否有问题

 // 为了和标准库区分，此处使用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 bit!!!");
     String s2(s1);
 }

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

浅拷贝

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

深拷贝

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

传统版写法的String类

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

 class String
 {
 public:
     String(const char* str = "")
    {
         if (nullptr == str)
        {
             assert(false);
             return;
        }

         _str = new char[strlen(str) + 1];
         strcpy(_str, str);
    }

     String(const String& s)
        : _str(nullptr)
    {  
         String strTmp(s._str);
         swap(_str, strTmp._str);
    }

     // 对比下和上面的赋值那个实现比较好？
    String& operator=(String s)
    {
         swap(_str, s._str);
         return *this;
    }
     /*
     String& operator=(const String& s)
     {
         if(this != &s)
         {
             String strTmp(s);
             swap(_str, strTmp._str);
         }

         return *this;
     }
     */
     ~String()
    {
         if (_str)
        {
             delete[] _str;
             _str = nullptr;
        }
    }
 private:
     char* _str;
 };