浅拷贝：实现不了，由于两个指针指向同一块空间，则空间释放时会释放两次，导致程序奔溃。这也是深拷贝与之不同要改进的地方。


    深拷贝：重新开辟空间，将原来的空间拷贝过来，再把值复制过来。（采用String的现代写法）



深拷贝：

#include
#include
using namespace std;

class String
{
public:
    String(const char* str)
        :_str(new char[strlen(str) + 1])  //  \0
    {
        strcpy(_str, str);
    }

    String(const String& s) 
        :_str(NULL)   //若不赋空则为随机值，随机值_str析构函数释放指针会崩溃
    {
        String tmp(s._str);     //重新开辟空间
        swap(_str, tmp._str);
    }

    String& operator = (const String& s)
     {
           if (this != &s) //不是自己给自己赋值
          {
              String tmp(s._str);   //重新开辟空间
              swap(_str, tmp._str);
          }
          return *this;
    }

    String& operator = (String s)
    {
        swap(_str, s._str);
        return *this;
    }

    ~String()
    {
        if (_str)
        {
            delete[] _str;    //注意与new char[n]匹配
        }
    }

    char* CStr()
    {
        return _str;
    }

    char& operator[](size_t index)  //重载输出单个字符
    {
        return _str[index];
    }

private:
    char* _str;
};

void Test()
{
    String s("change world");
    cout << s[1] << endl;

    s[1] = 'x';
    cout << s.CStr() << endl;
}

int main()
{
    Test();
    system("pause");
    return 0;
}


浅拷贝：

#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
#include
using namespace std;

class String
{
public:
    String(const char* str)
        :_str(new char[strlen(str) + 1])  // \0
    {
        strcpy(_str, str);
    }

    String(const String& str)
        :_str(str._str)
    {}

    String& operator =(const String& str)
    {
        if (this != &str)
        {
            _str = str._str;
        }
        return *this;
    }

    ~String()
    {
        if (_str)
        {
            delete[] _str;
        }
    }

private:
    char* _str;
};

void Test()
{
    String s1("hello world !");
    String s2 = s1;
}
int main()
{
    Test();
    system("pause");
    return 0;
}