string类

模拟实现string类

浅拷贝：

一个对象的值赋到另一个对象去（会出现程序崩溃或者内存泄露问题）

#include <iostream>
using namespace std;
class String
{
public:
    //构造函数
    String(const char* str = "")
    {
        if (str == NULL)
        {
            _str = new char[1];
            *_str = '\0';
        }
        else
        {
            _str = new char[strlen(str) + 1];//把'\0'也要拷贝进去
            strcpy(_str, str);
        }
    }
    //拷贝构造函数
    String(const String & s)
        :_str(s._str)
    {

    }
    //赋值运算符重载
    String & operator =(const String & s)
    {
        _str = s._str;
        return *this;
    }
    //析构函数
    ~String()
    {
        if (_str)
        {
            delete[] _str;
            _str = NULL;
        }
    }
private:
    char *_str;
};
int main()
{
    String p1;
    String p2("hello");
    String p3(p2);//程序崩溃，内存泄露
    return 0;
}

像上述的代码就是浅拷贝，它会给系统带来泄露的问题。就比如说上例中，p2本来指向了hello的这块空间，但是p3在经过构造函数之后，也指向了这块空间，到释放内存的时候。这快空间被释放了两次，就会出现内存泄露问题，如下图所示：
这里写图片描述

深拷贝（传统的深拷贝）：

#define  _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string.h>
using namespace std;
class String
{
public:
    //构造函数
    String(const char* str = "")
    {
        if (str == NULL)
        {
            _str = new char[1];
            *_str = '\0';
        }
        else
        {
            _str = new char[strlen(str) + 1];//把'\0'也要拷贝进去
            strcpy(_str, str);
        }
    }
    //拷贝构造函数
    String(const String & s)
        :_str(new char[strlen(s._str)+1])开辟新的空间
    {
        strcpy(_str,s._str);
    }
    //赋值运算符重载
    String & operator =(const String & s)
    {
        if (this != &s)
        {
            delete[] _str;//释放原来的空间
            _str = new char[strlen(s._str) + 1];//开辟新空间
            strcpy(_str, s._str);//拷贝值
        }
        return *this;
    }
    //析构函数
    ~String()
    {
        if (_str)//值为空不释放
        {
            delete[] _str;
            _str = NULL;
        }
    }
    void show()
    {
        cout << _str << endl;
    }
private:
    char *_str;
};
int main()
{
    //String p1;
    String p2("hello");
    String p3(p2);
    String p4;
    p4 = p3;
    p4.show();
    return 0;
}

深拷贝（简洁版）

这种只是针对于拷贝构造函数和运算符进行的重写

//简洁版的拷贝构造
    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);//变量出了局部作用域自动释放
        }
    }