C++String浅拷贝&深拷贝&Copy On Write

• 简单的赋值拷贝

class String
{
public:
    String(constchar*str)
        :_str(newchar [strlen(str)+1])
    {
        strcpy(_str,str);
    }
    String(constString&str)
        :_str(str._str)
    {}
    String& operator=(constString& str)
    {
        if(this!= &str)
        {
            _str=str._str;
        }
        return *this;
    }
    ~String()
    {
        if(_str)
        {
            delete[]_str;
        }
    }
private:
    char*_str;
};
voidTestString()
{
    Strings1("hello world!");
    Strings2=s1;
}

当类里面有指针对象时，进行简单赋值的浅拷贝，两个对象指向同一块内存，存在崩溃的问题！
这里我们要进行深拷贝。

• 深拷贝及String类的深浅拷贝实现（简单模拟string）
  
• 简单模拟String实现

#include 
#include 
using namespace std;

class String{
    //浅拷贝
public:
    String(const char* str = "")//1.构造
        :_str(new char[strlen(str)+1])
    {
        strcpy(_str,str);
    }
    //String(const String& s)//2.拷贝构造
    //  :_str(s._str)
    //{}
        //深拷贝：传统写法
        String(const String& s)
            :_str(new char[strlen(s._str) + 1])
        {
            strcpy(_str,s._str);
        }
    //  //深拷贝：现代写法
    //  String(const String& s)
    //      :_str(NULL)
    //  {
    //      String tmp(s._str);
    //      swap(_str,tmp._str); 
    //  }
      /*String& operator=(const String& s)
      {
          if (&s != this)
          {
              String tmp(s._str);
              swap(_str, tmp._str);
          }
          return *this;
      }*/
    String& operator=(const String& s)//3.赋值构造
    {
        if (&s != this)
        {
            char *str = new char[strlen(s._str) + 1];
            strcpy(str, s._str);
            delete[] _str;
            _str = str;
        }
        return *this;
    }
    const char* c_str()
    {
        return _str;
    }
    char& operator[](size_t pos)//下标运算符重载
    {
        return _str[pos];
    }

    ~String()//4.析构函数
    {
        if (_str != nullptr)
        {
            delete[] _str;
        }
    }
private:
    char* _str;
};

namespace COW  //copy on write
{

    class String{
        //写时拷贝: 经典写法
    public:
        String(const char* str = "")
            :_str(new char[strlen(str) + 1])
            , _pCount(new int(1))
        {
            strcpy(_str, str);
        }
        String(const String& s)
            :_str(s._str)
            , _pCount(s._pCount)
        {
            (*_pCount)++;
        }

        void CopyOnWrite()
        {
            if (*_pCount > 1)
            {
                char* newStr = new char[strlen(_str) + 1];
                strcpy(newStr, _str);
                _str = newStr;

                --(*_pCount);
                _pCount = new int(1);
            }
        }
        void Release()
        {
            if (--(*_pCount) == 0)
            {
                delete[] _str;
                delete _pCount;

                _str = NULL;
                _pCount = NULL;
            }
        }


        const char& operator[](size_t pos) const
        {
            return _str[pos];
        }
        char& operator[](size_t pos)
        {
            CopyOnWrite();
            return _str[pos];
        }
        ~String()
        {
            Release();
        }

    private:
        char* _str;
        int* _pCount;//引用计数
    };
}

int main(void)
{
    String s1("change world");
    String s2(s1);

    cout<'!');
    cout<"I am Coming");
    cout<"I am Coming";
    cout<'!';

    return 0;
}