97.重载类的+法与深拷贝构造(拷贝构造深拷贝,赋值深拷贝)

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <locale.h>
using namespace std;

//返回值为类的引用不会调用拷贝构造
//拷贝构造要深拷贝,赋值重载(=)也要深拷贝
//注意对象如果是在栈上,有生命周期,拷贝栈上的对象需要深拷贝

class mystring
{
public:
    char *p;
    int n;

public:
    mystring() : p(nullptr), n(0)
    {

    }
    mystring(char *str)
    {
        p = new char[strlen(str) + 1];
        n = strlen(str) + 1;
        strcpy(p, str);
    }

    mystring(const mystring &my)
    {
        n = my.n;
        p = new char[n];
        strcpy(p, my.p);
    }

    ~mystring()
    {
        delete p;
    }

    //void operator +(mystring &str)
    //{
    //    this->n += strlen(str.p);
    //    //分配内存
    //    char *ptemp = new char[this->n];
    //    //拷贝
    //    strcpy(ptemp, this->p);
    //    strcat(ptemp, str.p);
    //    delete this->p;
    //    this->p = ptemp;
    //}

    //返回一个对象
    //mystring operator +(mystring &str)
    //{
    //    this->n += strlen(str.p);
    //    //分配内存
    //    char *ptemp = new char[this->n];
    //    //拷贝
    //    strcpy(ptemp, this->p);
    //    strcat(ptemp, str.p);
    //    delete this->p;
    //    this->p = ptemp;

    //    return (*this);
    //}

    //如果返回的是引用则不会调用拷贝构造
    mystring &operator +(mystring &str)
    {
        this->n += strlen(str.p);
        //分配内存
        char *ptemp = new char[this->n];
        //拷贝
        strcpy(ptemp, this->p);
        strcat(ptemp, str.p);
        delete this->p;
        this->p = ptemp;

        return (*this);
    }
};

void main()
{
    mystring *my1 = new mystring("hello");
    mystring *my2 = new mystring("world");
    mystring my3 = *my1 + *my2;
    delete my1;
    cout << my3.p << endl;
    cin.get();
}