第12周项目-程序阅读（1）-优快云博客

本文通过三个示例程序详细解析了C++中多重继承的基本使用方法、二义性问题及其解决办法，以及虚基类的概念与应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/*
*copyright (c)2015,烟台大学计算机学院
*All rights reserved
*文件名称：project.cpp
*作者：孙春红
*完成日期：2015年5月25日
*版本号：v1.0
*
*问题描述：程序阅读。
*输入描述：略。
*程序输出：略。
*/

（1）阅读程序，写出执行结果
#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//类B继承了类A
{
public:
    B()
    {
        b=0;
    }
    B(int i, int j, int k): A(i),aa(j)
    {
        b=k;
    }
    //思考：这3处出现的print，有何区别
    void print()      //(1)类C本身的成员函数
    {
        A::print();   //(2)调用基类A的成员函数，
        aa.print();   //(3)类A的子对象的成员函数
        cout<<b<<endl;
    }
private:
    int b;
    A aa;//定义了一个子对象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;
}

运行结果：
1 4 7
2 5 8
知识点总结：
多重继承引起的二义性问题，当出现时，可以在数据成员或成员函数前加上域名以区分它们。
（2）阅读程序，写出执行结果

#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;  
}  

运行结果：
class A
class B
class C
class D
知识点总结：
多重继承的方法，以及理解多重继承派生类的构造函数的写法
（3）阅读程序，写出执行结果
#include <iostream>  
using namespace std;  
class Base  
{  
public:  
    Base(char i) { cout<<"Base constructor. --"<<i<<endl; }  
};  
class Derived1:virtual public Base  
{  
public:  
    Derived1(char i,char j):Base(i)  
    {  
        cout<<"Derived1 constructor. --"<<j<<endl;  
    }  
};  
class Derived2:virtual public Base  
{  
public:  
    Derived2(char i,char j):Base(i)  
    {  
        cout<<"Derived2 constructor. --"<<j<<endl;  
    }  
};  
class MyDerived:public Derived1,public Derived2  
{  
public:  
    MyDerived(char i,char j,char k,char l,char m,char n,char x): Derived2(i,j), Derived1(k,l), Base(m), d(n)  
    {  
        cout<<"MyDerived constructor. --"<<x<<endl;  
    }  
private:  
    Base d;  
};  
int main()  
{  
    MyDerived obj('A','B','C','D','E','F','G');  
    return 0;  
}  

运行结果：
Base constructor. --E
Derived1 constructor. --D
Derived2 constructor. --B
Base constructor. --F
MyDerived constructor. --G
学习心得：
运用单步执行，程序先运行Base的构造函数，然后运行deriveded1的构造函数，然后再是deriveded2的构造函数，最后运行子对象的构造函数
存在两个虚基类时，先运行那个先定义的那个。