C++虚基类详解

复制纯文本新窗口

1. class A //声明基类A
2. {
3. // 代码
4. };
5. class B: virtual public A //声明类B是类A的公用派生类，A是B的虚基类
6. {
7. // 代码
8. };
9. class C: virtual public A //声明类C是类A的公用派生类，A是C的虚基类
10. {
11. // 代码
12. };

class A  //声明基类A
{
    // 代码
};
class B: virtual public A  //声明类B是类A的公用派生类，A是B的虚基类
{
    // 代码
};
class C: virtual public A  //声明类C是类A的公用派生类，A是C的虚基类
{
    // 代码
};

复制纯文本新窗口

1. class A //定义基类A
2. {
3. A(int i){ } //基类构造函数，有一个参数};
4. class B :virtual public A //A作为B的虚基类
5. {
6. B(int n):A(n){ } //B类构造函数，在初始化表中对虚基类初始化
7. };
8. class C :virtual public A //A作为C的虚基类
9. {
10. C(int n):A(n){ } //C类构造函数，在初始化表中对虚基类初始化
11. };
12. class D :public B,public C //类D的构造函数，在初始化表中对所有基类初始化
13. {
14. D(int n):A(n),B(n),C(n){ }
15. };

class A  //定义基类A
{
   A(int i){ }  //基类构造函数，有一个参数};
class B :virtual public A  //A作为B的虚基类
{
   B(int n):A(n){ }  //B类构造函数，在初始化表中对虚基类初始化
};
class C :virtual public A  //A作为C的虚基类
{
   C(int n):A(n){ }  //C类构造函数，在初始化表中对虚基类初始化
};
class D :public B,public C  //类D的构造函数，在初始化表中对所有基类初始化
{
   D(int n):A(n),B(n),C(n){ }
};

复制纯文本新窗口

1. #include <iostream>
2. #include <string>
3. using namespace std;
4. //声明公共基类Person
5. class Person
6. {
7. public:
8. Person(string nam,char s,int a) //构造函数
9. {
10. name=nam;
11. sex=s;
12. age=a;
13. }
14. protected: //保护成员
15. string name;
16. char sex;
17. int age;
18. };
19.  
20. //声明Person的直接派生类Teacher
21. class Teacher:virtual public Person //声明Person为公用继承的虚基类
22. {
23. public:
24. Teacher(string nam,char s,int a, string t):Person(nam,s,a)//构造函数
25. {
26. title=t;
27. }
28. protected: //保护成员
29. string title; //职称
30. };
31.  
32. //声明Person的直接派生类Student
33. class Student:virtual public Person //声明Person为公用继承的虚基类
34. {
35. public:
36. Student(string nam,char s,int a,float sco) //构造函数
37. :Person(nam,s,a),score(sco){ } //初始化表
38. protected: //保护成员
39. float score; //成绩
40. };
41.  
42. //声明多重继承的派生类Graduate
43. class Graduate:public Teacher,public Student //Teacher和Student为直接基类
44. {
45. public:
46. Graduate(string nam,char s,int a, string t,float sco,float w)//构造函数
47. :Person(nam,s,a),Teacher(nam,s,a,t),Student(nam,s,a,sco),wage(w){}
48. //初始化表
49. void show( ) //输出研究生的有关数据
50. {
51. cout<<"name:"<<name<<endl;
52. cout<<"age:"<<age<<endl;
53. cout<<"sex:"<<sex<<endl;
54. cout<<"score:"<<score<<endl;
55. cout<<"title:"<<title<<endl;
56. cout<<"wages:"<<wage<<endl;
57. }
58. private:
59. float wage; //工资
60. };
61.  
62. //主函数
63. int main( )
64. {
65. Graduate grad1("Wang-li",'f',24,"assistant",89.5,1234.5);
66. grad1.show( );
67. return 0;
68. }

#include <iostream>
#include <string>
using namespace std;
//声明公共基类Person
class Person
{
public:
   Person(string nam,char s,int a)  //构造函数
   {
      name=nam;
      sex=s;
      age=a;
   }
protected:  //保护成员
   string name;
   char sex;
   int age;
};

//声明Person的直接派生类Teacher
class Teacher:virtual public Person  //声明Person为公用继承的虚基类
{
public:                                
   Teacher(string nam,char s,int a, string t):Person(nam,s,a)//构造函数
   {
      title=t;
   }
protected:  //保护成员
   string title;  //职称
};

//声明Person的直接派生类Student
class Student:virtual public Person  //声明Person为公用继承的虚基类
{
public:
   Student(string nam,char s,int a,float sco)  //构造函数
      :Person(nam,s,a),score(sco){ }  //初始化表
protected:  //保护成员
    float score;  //成绩
};

//声明多重继承的派生类Graduate
class Graduate:public Teacher,public Student  //Teacher和Student为直接基类
{
public:
   Graduate(string nam,char s,int a, string t,float sco,float w)//构造函数
   :Person(nam,s,a),Teacher(nam,s,a,t),Student(nam,s,a,sco),wage(w){}
   //初始化表
   void show( )  //输出研究生的有关数据
   {
      cout<<"name:"<<name<<endl;
      cout<<"age:"<<age<<endl;
      cout<<"sex:"<<sex<<endl;
      cout<<"score:"<<score<<endl;
      cout<<"title:"<<title<<endl;
      cout<<"wages:"<<wage<<endl;
   }
private:
   float wage;  //工资
};

//主函数
int main( )
{
   Graduate grad1("Wang-li",'f',24,"assistant",89.5,1234.5);
   grad1.show( );
   return 0;
}