模拟实现string（深浅拷贝，传统现代写法）

模拟实现string

浅拷贝

首先我们了解一下浅拷贝
浅拷贝是系统自动生成的也叫做值拷贝。

class String
{
public:
    String(char* str)
        :_str(str)
    {}

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

   ~String()
    {
        delete[] _str;
    } 只能释放一次
private:
    char* _str;

};
void Test1()
{
    String s1("s1");
    String s2(s1);
}

我们在运行这段代码时候程序会崩溃，这是为什么呢，用一幅图理解一下

出现这种问题我们的解决方案有两种
1，深拷贝
2，写时拷贝

深拷贝的写法有两种
一种是传统写法一种是现代写法

深拷贝——传统写法

class String
{
public:
    String(char* str = "")//无参函数也可用
        :_str(new char[strlen(str) + 1])
    {
        strcpy(_str, str);
    }

    //传引用返回可以提高效率，并且出了作用域对象还存在
    String(const String &s)
        :_str(new char[strlen(s._str)+1])
    {
        strcpy(_str, s._str);
    }
    char &operator[](size_t pos)
    {
        return _str[pos];
    }
    String &operator=(const String &s)
    {
        if (this != &s)
        {
            delete _str;
            _str = new char[strlen(s._str) + 1];
            strcpy(_str, s._str);
        }
        return *this;
    }

    ~String()
    {
        delete[] _str;
    }
    const char* GETStr()
    {
        return _str;
    }
private:
    char*_str;
};

深拷贝——现代写法

class String
{
public:
    String(char* str = "")//无参函数也可用
        :_str(new char[strlen(str) + 1])
    {
        strcpy(_str, str);
    }
    String(const String &s)
        :_str(NULL)
    {
        String tmp(s._str);
        swap(_str, tmp._str);

    }
    char &operator[](size_t pos)
    {
        return _str[pos];
    }
    String &operator=(const String &s)
    {
        if (this != &s)
        {
            String tmp(s);
            swap(_str, tmp._str);
        }
        return *this;
    }
    String &operator=(String s)
    {
        swap(_str, s._str);
        return *this;
    }

    ~String()
    {
        delete[] _str;
    }
    const char* GETStr()
    {
        return _str;
    }
private:
    char*_str;
};

这是我们深拷贝的两种写法
那么深拷贝在析构函数这里是怎么做到的呢

总结传统写法和现代写法：
传统写法：可读性高
现代写法：简洁 ，new/delete都在统一的地方，可维护性高