继承中的构造与析构

赋值兼容性原则：

子类对象可以当作父类对象使用：

子类对象可以直接赋值给父类对象；

子类对象可以直接初始化父类对象；

父类指针可以直接指向子类对象；

父类引用可以直接引用子类对象；

子类是就是特殊的父类！！！

class Child : public Parent
{
protected:
    int i;
public:
    Child(int i)//构造函数
    {
        this->name = "Child";
        this->i = i;
    }
};
int main(int argc, char *argv[])//子类就是特殊的父类
{
    Child child(1000);//定义一个子类对象
    Parent parent = child;//用子类对象初始化父类对象
    Parent* pp = &child;//父类对象指向子类对象
    Parent& rp = child;//父类对象引用子类对象
    
    parent.print(); 
    pp->print();
    rp.print();
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

继承对象模型：

类在 C++ 编译器的内部 可以理解为结构体；

  子类是由父类成员叠加子类新成员得到的；

继承与构造：

在子类对象 构造的时候 需要调用 父类构造函数 对其 继承得来的成员 进行初始化

继承与析构：

在子类对象 析构的时候 需要调用 父类析构函数 对其 继承得来的成员 进行清理；

class Parent
{
public:
    Parent()//构造函数
    {
        cout<<"Parent()"<<endl;
    }
    
    ~Parent()//析构函数
    {
        cout<<"~Parent()"<<endl;
    }
};


class Child : public Parent
{
public:
    Child()//构造函数
    {
        cout<<"Child()"<<endl;
    }
    
    ~Child()//析构函数
    {
        cout<<"~Child()"<<endl;
    }
};


void run()
{
    Child child;//child对象，子类构造时需要先调用父类的构造函数，
}

子类对象在创建时会首先调用父类的构造函数；

父类构造函数执行结束后，执行子类的构造函数；

当父类的构造函数有参数时，需要在子类的初始化列表中显示调用；

析构函数调用的先后顺序与构造函数相反；

继承与组合的混搭：

组合：类中的成员变量可以是其它类的对象

class Object
{
public:
    Object(const char* s)
    {
        cout<<"Object()"<<" "<<s<<endl;
    }
};


class Parent : public Object
{
public:
    Parent(const char* s) : Object(s)//有参，显示调用
    {
        cout<<"Parent()"<<" "<<s<<endl;
    }
};


class Child : public Parent//混搭风，继承与组合
{
protected:
    Object o1;//先初始化o1,因为先定义
    Object o2;
public:
    Child() : o2("o2"), o1("o1"), Parent("Parameter from Child!")//初始化列表
    {
        cout<<"Child()"<<endl;
    }
};//成员初始化也应该放到初始化列表中，初始化列表中元素顺序与初始化的顺序无必然联系
//混搭风调用原则：先父母，再客人，后自己


void run()
{
    Child child;
}

同名成员变量：

当子类成员变量与父类成员变量同名时：

子类依然从父类继承同名成员；

在子类中通过作用域分别符 :: 进行同名成员区分；

同名成员存储在内存中的不同位置；

class Parent
{
protected:
    int i;
    int f;
};


class Child : public Parent
{
protected:
    int i;
    
    void f()
    {
        cout<<"Parent::i = "<<Parent::i<<endl;
        cout<<"Child::i = "<<Child::i<<endl;
        cout<<"Parent::f = "<<Parent::f<<endl;
    }
public:
    Child(int i, int j)
    {
        Parent::i = i;//作用域分辨符
        Child::i = j;
        Parent::f = i + j;
        
        f();//打印输出的值
    }
};

子类对象可以当作父类对象使用；

子类对象在创建时需要调用父类构造函数进行初始化；

子类对象在销毁时需要调用父类析构函数进行清理；

先执行父类构造函数，再执行成员构造函数；

在继承中的析构顺序与构造顺序对称相反；

同名成员通过作用域分辨符进行区分；