第十周练习 继承机制阅读程序

/*  
 *Copyright(c) 2016,烟台大学计算机学院  
 *作    者：刘金石  
 *完成日期：2016年5月3日  
 *问题描述：继承机制阅读程序 
*/ 
#include <iostream>
using namespace std;
class Data
{
public:
    Data(int i):x(i){cout<<"A";}
    ~Data(){ cout<<"B";}
private:
    int x;
};
class Base
{
public:
    Base(int i):b1(i){cout<<"C";}
    ~Base(){ cout<<"D";}
private:
    int b1;
};
class Derived:public Base
{
public:
    Derived (int i,int j):Base(i),d1(j){
        cout<<"E";
    }
    ~Derived(){cout<<"F";}
private:
    Data d1;
};
int main()
{
    Derived obj(1,2);
    return 0;
}

程序分析：

类Derived与类Date是组合guanxi，同时类Derived又继承了类Base
在主函数中，定义类Derived的对象obj，参数为（1，2），首先调用类Derived的构造函数
因为在子类的构造函数中应该先构造基类的参数，所以程序调用构造函数Base，输出 C
然后构造d1，程序调用Date的构造函数，输出 A
Derived函数中输出 E
然后程序调用Derived的析构函数，输出 F
然后调用Date的析构函数 输出 B
最后调用Base的析构函数 输出 D

运行结果：

<img src="https://img-blog.csdn.net/20160503140036650?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" alt="" />

程序2；

#include <iostream>
using namespace std;
class A
{
public:
    A(){a=0;}
    A (int i){a=i;}
    void print(){cout<<a<<"  ";}
private:
    int a;
};
class B: public A
{
public:
    B(){b=0;}
    B(int i, int j, int k): A(i),aa(j){b=k;}
    //思考：这3处出现的print，有何区别
    void print()      //(1)
    {
        A::print();   //(2)
        aa.print();   //(3)
        cout<<b<<endl;
    }
private:
    int b;
    A aa;
};
int main()
{
    B test[2];
    test[0]=B(1,4,7);
    test[1]=B(2,5,8);
    for(int i=0; i<2; i++)
        test[i].print();
    return 0;
}

程序分析：

类B继承了类A，同时类A又是类B的数据成员
在类B中的三个print是不一样的：
（1）表示类B中的一个成员函数
（2）表示用类名调用A类中的成员函数
（3）表示对象aa调用成员函数*/

运行结果：

<img src="https://img-blog.csdn.net/20160503140153854?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" alt="" />

程序3：

#include <iostream>
using namespace std;
class A
{
public:
    A(char *s){cout<<s<<endl;}
};
class B:public A
{
public:
    B(char *s1, char *s2):A(s1){
        cout<<s2<<endl;
    }
};
class C:public A
{
public:
    C(char *s1,char *s2):A(s1){
        cout<<s2<<endl;
    }
};
class D:public B, C
{
public:
    D(char *s1,char *s2,char *s3,char *s4):
        B(s1,s2),C(s3,s4){cout<<s4<<endl;}
};
int main()
{
    D d("class A","class B","class C","class D");
    return 0;
}

程序分析：

类B和类C都继承了类A，类D同时继承了类B和类C
所以类D的构造函数中应先构造B，又因为类B继承了A，所以要先构造A，故首先输出 class A
然后B的构造函数中又输出s2即 class B
接着在D的构造函数中构造类C，又因为C继承了A，所以先构造A，输出 class C
然后在C的构造函数中输出 class D
最后类D的构造函数初始化列表完成后，程序执行输出s4即输出 class D

运行结果：

<img src="https://img-blog.csdn.net/20160503140322526?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" alt="" />