C++ 三道题搞定继承

#include <iostream>
using namespace std;

class A
{
    int a;
public:
    A(int i)
    {
        a = i;
        cout<<"A Constructor"<<endl;
    }
    void disp()
    {
        cout<<"a="<<a<<endl;
    }
};

class B
{
    int b;
public:
    B(int i)
    {
        b = i;
        cout<<"B Constructor"<<endl;
    }
    void disp()
    {
        cout<<"b="<<b<<endl;
    }
};

class C: public B, public A
{
    int c;
public:
    C(int k):A(k-2),B(k+2),ma2(k-1),ma1(k+1)
    {
        c = k;
        cout<<"C Constructor"<<endl;
    }
    A ma1;
    A ma2;
    void disp()
    {
        A::disp();
        B::disp();
    }
};

int main()
{
    C obj(10);
    obj.disp();
    return 0;
}

这题的输出是：

B Constructor
A Constructor
A Constructor
A Constructor
C Constructor
a=8
b=12

分析一下：

首先，构造派生类对象时，先调用基类的构造函数， 按照继承的先后顺序调用基类的构造函数。class C：public B， public A，这句话，可以看出，先继承B，所以先调用B的构造函数，在调用A的构造函数。当派生类对象中出现子对象时，先调用子对象的构造函数，所以接着构造ma1, 在构造ma2, 最后调用派生类的构造函数，输出C Constructor;

C(int k):A(k-2),B(k+2),ma2(k-1),ma1(k+1)

通过参数列表给基类构造函数和子对象构造函数赋值

输出disp的时候，A：：disp（），输出k-2的值，在调用B：：disp（），输出k+2的值。

#include <iostream>
using namespace std;

class A
{
public:
    A()
    {
        cout<<"A Constructor"<<endl;
    }
    virtual ~A()
    {
        cout<<"A Destructor"<<endl;
    }
    virtual void f()
    {
        cout<<"A::f()"<<endl;
    }
    void g()
    {
        f();
    }
};

class B: public A
{
public:
    B()
    {
        f();
        cout<<"B Constructor"<<endl;
    }
    ~B()
    {
        cout<<"B Destructor"<<endl;
    }
};

class C: public B
{
public:
    C()
    {
        f();
        cout<<"C Constructor"<<endl;
    }
    ~C()
    {
        cout<<"C Destructor"<<endl;
    }
    void f()
    {
        cout<<"C::f()"<<endl;
    }
    
};

int main()
{
    A * p = new C;
    p->g();
    delete p;
}

这道题的输出是：

A Constructor
A::f()
B Constructor
C::f()
C Constructor
C::f()
C Destructor
B Destructor
A Destructor

分析一下：

首先调用C的构造函数，而C的派生类，所以先调用C的父类B，但是此时B也是派生类，所以调用B的父类的构造函数A Constructor，然后调用B的构造函数，此时运行f（），应为f（）为虚函数，在虚表指针里面，A::f（）的函数指针没有被覆盖，所以调用的仍然是A：：f（），在输出B Constructor， 在调用C的构造函数，同样，也是先执行f（）函数，但此时，f（）重载了，所以虚表里面的函数指针指向的是C：：f（），所以输出C：：f（），在输出C Constructor;在执行g（）函数，而g（）函数里面是调用f（），所以f（）的函数指针是指向后面覆盖的函C：：f（），所以再次输出C：：f（），最后反序析构，先析构C，在系够B，在析构A。

第三题：

#include <iostream>
using namespace std;

class Base 
{
public:
    Base()
    {
    }
    virtual void f()
    {
        cout<<"Base::f() called!"<<endl;
    }
    virtual ~Base()
    {
        cout<<"~Base()---";
        f();
    }
};

class De: public Base
{
public:
    De ()
    {
    }
    void f()
    {
        cout<<"De::f() called!"<<endl;
    }
    ~De()
    {
        cout<<"~Base()---";
        f();
    }
};

int main()
{
    De d;
    Base b = d, *pb = new De;
    b.f();
    pb->f();
    delete pb;
}

运行结果是：

Base::f() called!
De::f() called!
~Base()---De::f() called!
~Base()---Base::f() called!
~Base()---Base::f() called!
~Base()---De::f() called!
~Base()---Base::f() called!

分析一下：

首先d对象被构造，其次b对象被构造，然后pb对象对构造，构造函数里面什么都没有，所以没有输出，此时记住，由于f（）是virtual，所以虚表指针指向的是De：：f（），用d对象初始化b对象时，调用基类的默认拷贝构造函数，不显示，构造pb对象的时候，先调用基类构造，再调用De的构造函数。

b.f()和执行的时候，调用的是基类的f（），而pb->f（）执行的时候，调用的派生类的f（），因为指向基类的指针，调用virtual函数的时候，通过虚表指针，调用的是派生类的函数。

delete pb的时候，由于析构函数是虚函数，所以先调用派生类析构函数，再调用基类的析构函数;所以先输出～Base（）---De：：f（） called！，在调用子类的析构，此时De：：f（）被析构了，属于输出基类的Base：：f（），

然后系够b对象，输出~Base()---Base::f() called!， 然后析构d对象，

总结一下继承：

参考：点击打开链接

继承的时候，要对基类成员吸收改造，集成包括公有集成，保护集成和私有集成，公有继承是基类是不改变成员的属性，公有的继承以后还是公有的，保护的继承以后还是保护的，对于保护的继承，公有的和保护的成员在子类里面都是保护的属性，对于私有继承，公有的和保护的成员在子类里面都是私有的。私有成员，无论是哪种方式的继承，在子类里面都是不可见的，

下面列出三种不同的继承方式的基类特性和派生类特性。

	public	protected	private
共有继承	public	protected	不可见
私有继承	private	private	不可见
保护继承	protected	protected	不可见

公有成员是外部可见，子类可见，保护成员是外部不可见，子类可见，私有成员是谁都不可见，

所以对基类成员的吸收和改造，就是继承基类的成员，然后修改他们的属性。而继承的时候，如果有虚函数，则子类和基类都有虚表指针vptr，

类型兼容规则：

派生类对象可以赋值给基类对象;

派生类的对象可以初始化鸡肋的引用;

派生类对象的地址可以赋给指向基类的指针;

声明一个对象时，调用构造函数，并且在stack中申明空间，stack中的对象由编译器自动的销毁，而new 操作，是在堆中开辟空间大小，调用构造函数。只能通过delete操作销毁。

可以用子类对象指针给基类对象指针赋值，

虚函数：

虚函数只能有成员函数来调用或者通过指针/引用来访问虚函数。

析构基类对象时，如果析构函数申明为虚函数时，先调用派生类的析构函数，再调用基类的析构函数。