字符类->浅拷贝与深拷贝

首先就深浅拷贝的问题做一个解释；

所谓浅拷贝，也称位拷贝，就是在类中拷贝构造函数以及赋值运算符重载时。通过直接将指针的值拷贝，与原对象共用一个空间；
而深拷贝，在以所述的两种函数中重新申请一块空间存放新的对象；
系统自动生成的拷贝构造即为浅拷贝；

class String
{
public:
    String(const char* pStr = "")
    {
        if (NULL == pStr)
        {
            _pStr = new char[1];
            *_pStr = '\0';
        }
        else
        {
            _pStr = new char[strlen(pStr) + 1];
            strcpy(_pStr, pStr);
        }
    }

    String(const String &s)
        :_pStr(s._pStr)
    {
    }
    String& operator=(const String& s)
    {
        if (this != &s)
        {
            delete[]_pStr;
            _pStr = s._pStr;
        }
        return *this;
    }
    ~String()
    {
        delete[]_pStr;
        _pStr = NULL;
    }
private:
    char* _pStr;
};

在这种浅拷贝的情况下，不难发现当析构时由于浅拷贝会对同一块空间两次释放，为了避免这种情况，我们对这种浅拷贝进行改造：带有引用计数，用指针指向引用计数的空间；

private:
    char* _pStr;
    int* _pCount;

添加一个新的成员：一个整型指针用来存放当前指向同一空间的对象个数
首先是构造函数与拷贝构造函数：

String(const char* pStr = "")//构造
        :_pCount(new int[1])
    {
        if (NULL == pStr)
        {
            _pStr = new char[1];
            *_pStr = '\0';
        }
        else
        {
            _pStr = new char[strlen(pStr) + 1];
            strcpy(_pStr, pStr);
        }
        *_pCount=1;
    }

    String(const String &s)//拷贝构造
        :_pStr(s._pStr)
        , _pCount(s._pCount)
    {
        (*_pCount)++;//注意优先级
    }

赋值运算符重载时，需注意原对象的空间是否还有其他对象在使用，若无便释放，若有则计数减一；

代码如下：

String& operator=(const String& s)
    {
        if (this != &s)
        {
            if (0 == --(*_pCount))
            {
                delete[]this;
            }
            _pStr = s._pStr;
            _pCount = s._pCount;
            (*_pCount)++;
        }
        return *this;
    }

最后是析构函数，检测计数是否为一，判断是否释放空间

    ~String()
    {
        if (0 == --(*_pCount))
        {   
            delete[]_pStr;
            delete[]_pCount;
            _pStr = NULL;
            _pCount = NULL;
        }
    }

这种使用计数指针的方法可以避免浅拷贝的出错，但多出一个指针成员终归是不理想的，参考new[]的做法，我们可以将这个计数放在所申请的空间前，只需多申请4个字节以及做一些处理；

class String
{
public:
    String(const char* pStr = "")
        :_pStr(new char[strlen(pStr) + 4+1])
    {
        *((int *)_pStr) = 1;
        _pStr += 4;
        strcpy(_pStr, pStr);
    }

    String(const String &s)
        :_pStr(s._pStr)
    {
        ++(*((int *)(_pStr - 4)));
    }
    String& operator=(const String& s)
    {
        if (this != &s)
        {
            if (0 == --(*((int *)(_pStr - 4))))
            {
                _pStr -= 4;
                delete[] _pStr;
            }
            _pStr = s._pStr;
            ++(*((int *)(_pStr - 4)));
        }
        return *this;
    }
    ~String()
    {
        if (0 == --(*((int *)(_pStr - 4))))
        {   
            _pStr -= 4;
            delete[]_pStr;
            _pStr = NULL;
        }
    }
private:
    char* _pStr;
};

下面介绍深拷贝

class String
{
public:
    String(const char* pStr = "")
    {
        if (NULL == pStr)
        {
            _pStr = new char[1];
            *_pStr = '\0';
        }
        else
        {
            _pStr = new char[strlen(pStr) + 1];
            strcpy(_pStr, pStr);
        }
    }

    String(const String &s)
        :_pStr(new char[strlen(s._pStr)+1])
    {
        strcpy(_pStr, s._pStr);
    }
    String& operator=(const String& s)
    {
        if (this != &s)
        {
            char* pTemp = new char[strlen(s._pStr) + 1];
            strcpy(pTemp, s._pStr);
            delete[]_pStr;
            _pStr = pTemp;
        }
        return *this;
    }
    ~String()
    {
        delete[]_pStr;
        _pStr = NULL;
    }
private:
    char* _pStr;
};

与浅拷贝原始函数相比，仅拷贝构造函数与赋值运算符重载需要修改
再运用swap函数对其改造

    String(const String &s)
        :_pStr(NULL)
    {
        String str(s._pStr);
        swap(_pStr, str._pStr);
    }

修改后的拷贝构造，需注意要将_pStr赋空指针，否则会造成销毁野指针而出错；

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

赋值运算符重载中，利用拷贝构造一个s，出函数时会对其进行析构，函数中利用s对this中的指针进行交换赋值。