【C++】c++String类浅拷贝、深拷贝

在了解深拷贝以及写时拷贝之前，我们先来了解什么是浅拷贝，看下面代码：

class String
{
public:
    String(char* ptr = "")
        :_ptr(new char[strlen(ptr)+1])
    {
        if (_ptr != NULL)//空间开辟成功
        {
            strcpy(_ptr, ptr);
        }
    }
    String(const String& s)
        :_ptr(s._ptr)//直接赋值
    {}
    String& operator= (const String& s)
    {
        if (this != &s)
        {
            delete[] _ptr;
            _ptr = s._ptr;//直接赋值
        }
        return *this;
    }
    ~String()
    {
        if (_ptr)
        {
            delete[]_ptr;
        }
    }
private:
    char* _ptr;
};

如下：s1、s2、s3是String类的三个对象，执行下列代码，目的是让s1、s2、s3在各自的内存空间内存放着字符串”sulijuan“，但却事与愿违。

String s1("sulijuan");
String s2(s1);
String s3;
s3 = s1;

可以通过调试看到最后s1、s2、s3都指向了同一块空间：

---

执行过程如下：

---

那么可想而知，最后释放对象的时候，理应调用三次析构函数来释放三个对象，s3最先被释放，当s3被释放了以后，同时把s1、s2指向的空间一起释放了，当再次调用析构函数想释放s2时，程序崩溃了~因为s2对象的_ptr指针指向的空间已经还给了操作系统，试图去释放一个不属于你的空间必然崩溃~~~~~~~~

---

.为了解决浅拷贝的问题，引入了深拷贝。。。。。。。。

浅拷贝是多个对象指向了同一块空间，导致最后释放空间出现了问题；那么深拷贝俗一点讲就是让每个对象对应一块空间，各自管各自的空间，互不影响，最后释放各自的空间。

代码如下：

class String
{
public:
    String(char* ptr = "")           //构造函数
        :_ptr(new char[strlen(ptr)+1])
    {
        if (_ptr)
        {
            strcpy(_ptr, ptr);
        }
    }
    String(const String& s)
        :_ptr(new char[strlen(s._ptr)+1])//另外开辟空间
    {
        strcpy(_ptr, s._ptr);
    }
    String& operator= (const String& s)
    {
        if (this != &s)
        {
            delete[] _ptr;
            _ptr = new char[strlen(s._ptr) + 1];//另外开辟空间
            strcpy(_ptr, s._ptr);
        }
        return *this;
    }
    ~String()
    {
        if (_ptr)
        {
            delete[] _ptr;
        }
    }
private:
    char* _ptr;
};

再次执行下面代码：

String s1("sulijuan");
String s2(s1);
String s3;
s3 = s1;

调试后可知各自开辟了一块空间：

---

---

模拟库内string类的一些字符串基本操作实现如下：

#define EXPLAND_CAPICITY 5
class String
{
public:
    String()                       //无参构造函数
        :_size(0)
        , _capicity(EXPLAND_CAPICITY)
        , _str(new char[EXPLAND_CAPICITY])
    {
        *_str = '\0';
    }
    String(char* str)               //构造函数重载
        :_size(strlen(str))           //根据声明先后顺序进行初始化
        , _capicity(_size+1)
        , _str(new char[_capicity])
    {
        strcpy(_str,str);
    }
    String(const String& s)         //深拷贝函数
        :_size(s._size)
        , _capicity(s._capicity)
        , _str(new char[strlen(s._str)+1])
    {
        strcpy(_str,s._str);
    }
    ~String()                      //析构函数 
    {
        if (_str)
        {
            delete[] _str;   
        }
    }
    String& operator=(const String& s)       //赋值运算符重载
    {
        if (this != &s)
        {
            delete[] _str;
            _str = new char[strlen(s._str)+1];
            strcpy(_str,s._str);
            _size = s._size;
            _capicity = s._capicity;
        }
        return *this;
    }
    void _CheckCapicity(int sCapicity)
    {
        if (_capicity - (_size + 1) < sCapicity)//检查当前容量是否足以容下将要插入字符串的长度
        {
            char* tmp = new char[_capicity + sCapicity];
            _capicity += sCapicity;
            strcpy(tmp, _str);       //_size没变
            delete[] _str;           //将原来空间释放掉
            _str = tmp;              //_str指向新开辟的空间
        }
    }
    void PushBack(char str)//尾插一个字符
    {
        _CheckCapicity(EXPLAND_CAPICITY);//如果当前所剩余的容量小于5，则每次增加容量5，否则不增加
        _str[_size++] = str;    //将本来的'\0'改掉了
        _str[_size] = '\0';     //新的结尾
    }
    void PushBack(char* str)//尾插字符串
    {
        assert(str);
        char* ptr = str;
        int strLen = strlen(str);
        _CheckCapicity(strLen);
        while (strLen--)
        {
            _str[_size++] = *ptr++;
        }
        _str[_size] = '\0';
    }
    void PopBack()       //尾删字符
    {
        if (_size > 0)
        {
            _str[--_size] = '\0';
        }
    }
    void Insert(int index,char str)        //在下标为index处插入一个字符
    {
        assert(index < _size);
        _CheckCapicity(EXPLAND_CAPICITY);
        int i = _size;
        for (; i>=index; --i)
        {
            _str[i+1] = _str[i];
        }
        _str[index] = str;
        _size++;
    }
    void Insert(int index,char* str)      在下标为index后面插入字符串
    {
        assert(index < _size);
        int strLen = strlen(str);
        _CheckCapicity(strLen);
        int i = _size;
        for (; i > index; i--)           
        {
            _str[i + strLen] = _str[i];      //把一个字符一次性挪到位
        }
        int j = index+1;
        char* ptr = str;
        while (strLen--)
        {
            _str[j++] = *ptr++;           //循环一个一个插入字符
            _size++;
        }
    }
    int Find(char str)//查找一个字符
    {
        int i = 0;
        for (; i < _size; i++)
        {
            if (_str[i] == str)
            {
                return i;
            }
        }
        return -1;
    }
    int Find(char* str)//查找字串
    {
        assert(str);
        int len = strlen(str);
        int i, j, k;
        for (i = 0; i < _size; i++)
        {
            k = i;
            for (j = 0; j < len; j++,k++)
            {
                if (_str[k] != str[j])
                {
                    break;
                }
            }
            if (str[j] == '\0')
            {
                return i;
            }
        }
        return -1;
    }
    /关系运算符重载函数
    bool operator== (const String& s)
    {
        char* ptr1 = _str;
        char* ptr2 = s._str;
        while (*ptr1 == *ptr2)
        {
            if (*ptr1 == '\0')
            {
                return true;
            }
            ptr1++;
            ptr2++;
        }
        return false;
    }
    bool operator!= (const String& s)
    {
        return !(*this == s);
    }
    bool operator> (const String& s)
    {
        char* ptr1 = _str;
        char* ptr2 = s._str;
        while (*ptr1 == *ptr2)
        {
            if (*ptr1 == '\0')
            {
                return false;
            }
            ptr1++;
            ptr2++;
        }
        if (*ptr1 > *ptr2)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool operator>= (const String& s)
    {
        return (*this > s) || (*this == s);
    }
    bool operator< (const String& s)
    {
        return !(*this >= s);
    }
    bool operator<= (const String& s)
    {
        return !(*this > s);
    }
    //算术运算符重载函数
    String operator+ (const String& s)
    {
        String tmp(*this);
        tmp.PushBack(s._str);
        return tmp;
    }
    String& operator += (const String& s)
    {
        *this = *this + s;
        return *this;
    }
    friend ostream& operator<< (ostream& os, const String& s);//输出<<运算符重载
private:
    int _size;          //字符个数
    int _capicity;      //字符串容量
    char* _str;            //指向字符串
};
ostream& operator<< (ostream& os,const String& s)
{
    os << s._str<<endl;
    return os;
}