继承中构造、析构 与 拷贝构造、赋值中的调用区别

有错误欢迎批评指正！谢谢！

1.当一个类继承另一个类的时候，子类构造函数与析构函数在自己的类中不需要显示调用父类的构造函数与析构函数

2.当一个类继承另一个类的时候，子类的拷贝构造函数需要显示的调用父类的拷贝构造函数，且必须按初始化的方式调用!

3.当一个类继承另一个类的时候，子类的赋值函数也需要显示的调用父类的赋值函数

#include<iostream>
using namespace std;
int i=1;
class base{
public:
    base(){
        valueBase=i;
        i++;
        valueBase2=i;
        i++;
        printf("base create!\n");
    }

    base(base &temp){
        valueBase=temp.valueBase;
        valueBase2=temp.valueBase2;
        printf("base copy create!\n");
    }

    base& operator =(const base & temp){
        valueBase=temp.valueBase;
        valueBase2=temp.valueBase2;
        printf("base = operator!\n");
        return *this;
    }

    ~base(){
        printf("delete base!\n");
    }
    int valueBase;
    int valueBase2;
};

class child:public base{
public:
    child(){
        
        p=new char;
        *p='0'+i;
        printf("child create!\n");
    }
    
    child(child &temp):base(temp){

        //base::base(temp); //一定写成上面初始化的方法，否则会有临时变量产生，且父类赋值不正确,其实这样是将值赋给了临时变量而不是正真的父类
        p=new char;
        *p=*temp.p;
        printf("child copy create!\n");
    }

    child& operator =(const child & temp){

        base::operator=(temp); //赋值函数必须显示的调用父类的赋值函数，否则不会去执行父类的赋值函数

        *p=*temp.p;
        printf("child = operator!\n");
        return *this;
    }
    ~child(){
        printf("delete child!\n");
    }
    char *p;
};


void fun(){
    child p2;
    child p5(p2);
    p5=p2;
}

int main(){
    fun();

    getchar();
}

为什么？当一个类继承另一个类的时候，子类的拷贝构造函数需要显示的调用父类的拷贝构造函数，且必须按初始化的方式调用!

    child(child &temp){
        base::base(temp); 
        p=new char;
        *p=*temp.p;
        printf("child copy create!\n");
    }

与

    child(child &temp):base(temp){
        p=new char;
        *p=*temp.p;
        printf("child copy create!\n");
    }

有什么区别？

前者将会构造产生一个临时父类对象，且把值赋给这个临时父类对象，而不是正真的父类对象！

调试：

发现this指针不是指向p5，指向了一个临时产生的父类对象

 

后者就是将值赋给真正的父类对象。

 

很明显this指针指向p5