深拷贝

带有指针的类，必须有拷贝构造和拷贝赋值构造函数。

MyString.hpp

#include <iostream>

//带有指针的类 必须有 拷贝构造(copy) 和 拷贝赋值(op=)

class myString
{
public:
    myString(const char* cstr = nullptr);
    myString(const myString& str); //拷贝构造(带有指针的深拷贝，浅拷贝，调用默认的拷贝构造，会出现内存泄漏)
    myString& operator=(const myString &);
    ~ myString();

    char* get_c_char()const{return m_data;};//inline function


private:
    int m_len;
    char *m_data;
};

MyString.cpp

#include <iostream>
#include <cstring>

#include "myString.hpp"

using namespace std;
//普通的构造函数
myString::myString(const char* cstr)
{
    cout << "normal construct" << endl;
    if(cstr!=nullptr)
    {
        m_len = strlen(cstr);
        m_data = new char[m_len + 1]{0};    //分配内存
        strncpy_s(m_data, sizeof(m_data), cstr, m_len);     //拷贝字符串
        cout<< m_data << endl;
    }
    else //空字符串
    {
        m_data = new char[1];                   //只分配一个字符空间，用来存储'\0'
        *m_data = '\0';
    }
}

myString::~myString()
{
    cout << "De-constructer called" << endl;
    delete[] m_data;
    m_data = nullptr;
}

//拷贝构造函数

myString::myString(const myString& str)         
{
    cout << "copy construct called" << endl;
    //deep copy  
    m_len = strlen(str.m_data);
    m_data = new char[m_len+1]{0};  //here must initialize the m_data
    strncpy_s(m_data, sizeof(m_data), str.m_data, m_len);     //拷贝字符串
    cout << m_data << endl;
}


myString& myString::operator=(const myString& str)
{   
    //赋值的过程：
    //1 销毁自己
    //2 重分配空间 
    //3 返回*this   
    //检测自我赋值
    cout << "operator= construct called" << endl;
    if(this == &str)
    {
        return *this;
    }
    
    delete[] m_data;
    m_data = new char[strlen(str.m_data)+1]{0};
    strncpy_s(m_data, sizeof(m_data),  str.m_data, strlen(str.m_data));
    return *this;
}

main.c

#include <iostream>
#include "myString.hpp"

int main()
{
    std::cout<< "hello" <<std::endl;
    char s1[]="string1";
    char s2[]="string2";

    myString mstr1(s1);
    myString mstr2(s2);    

    mstr2 = mstr1;          //myString mstr3 = mstr1;  不会调用operator = construct fun
    std::cout << mstr2.get_c_char() << std::endl;
 
    myString mstr3(mstr2);  //深拷贝构造
    std::cout << mstr3.get_c_char() << std::endl;


}