29）深拷贝和浅拷贝

1）浅拷贝，就是单单的将数值拷过去，包括你的指针指向

2）那么就有一个问题了（浅拷贝）

　　

#include<iostream>
#include<string>
using namespace std;


class Teacher{
public:
    Teacher(int id,char *name)
    {
        this->id=id;
        int len=strlen(name);

        this->name=(char*)malloc(len+1);
        strcpy(this->name,name);
    }
    Teacher(const Teacher &another)
    {
        this->name=another.name;
        this->id=another.id;
    }
    ~Teacher()
    {
        cout<<"Teacher的析构函数"<<endl;
        if(this->name!=NULL)
        {
            free(this->name);
            this->name=NULL;
        }
        
    }
private:
    char *name;
    int id;

};
//为啥有这个函数，因为想要我实例化的对象好 析构掉，只要我调用了这个函数，之后就会把这个函数里的对象给析构掉
void hanshu()
{
    Teacher t1(1,"王超");
    Teacher t2=t1;
}
int main()
{
    hanshu();

//后面，那个hanshu（）里的对象就被袭析构掉了
    return 0;
}

　　　　

  这个的关系类图是：

　　　　

　　　　然后就是那个t2 就是这样的。

　　　　

　　　　 但是我调用完 hanshu（）后，先析构t2    那么那块对内存被回收了

　　　　 然后，我又回收t1    那个t1的name不是空   还是调用那个free函数，但是  那块内存已经被回收了，所以就有了错误，系统就崩掉了

这个是浅拷贝带来的问题

然后，就有可深拷贝，来避免这个问题

需要一个显式的深构造函数，来完成深构造函数

只要你的类成员中有一个指针，就需要 提供一个手动深构造函数，来完成深拷贝动作。

#include<iostream>
#include<string>
using namespace std;


class Teacher{
public:
    Teacher(int id,char *name)
    {
        this->id=id;
        int len=strlen(name);

        this->name=(char*)malloc(len+1);
        strcpy(this->name,name);
    }
    //新加的拷贝构造函数
    Teacher(const Teacher &another)
    {
        id=another.id;
        //深拷贝动作
        int len=strlen(another.name);
        name=(char*)malloc(len+1);
　　　　　　strcpy(name,another.name);
    }

    ~Teacher()
    {
        cout<<"Teacher的析构函数"<<endl;
        if(this->name!=NULL)
        {
            free(this->name);
            this->name=NULL;
        }
        
    }
private:
    char *name;
    int id;

};
void hanshu()
{
    Teacher t1(1,"王压抑");
    Teacher t2=t1;
}
int main()
{
    hanshu();
    return 0;
}

 

然后就变成了：