十、继承与派生 - 五、多重继承 - 《编程基础》

1.声明多重继承的方式

class D:public A,private B,protected C

{类D新增加的成员}

D是多重继承的派生类
以公用继承方式继承A类，
以私有继承方式继承B类，
以保护继承方式继承C类。
D按不同的继承方式的规则继承A,B,C的属性，确定各基类的成员在派生类中的访问权限。

2.多重继承派生类的构造函数**

多重继承派生类的构造函数形式与单继承时的构造函数形式基本相同，在初始表中包含多个基类构造函数。

如：派生类构造函数名**(总参数表列): 基类1构造函数(参数表列),
基类2构造函数(参数表列), 基类3构造函数 (参数表列**)
{**派生类中新增数成员据成员初始化语句**}

派生类构造函数的执行顺序同样为: 先调用基类的构造函数，再执行派生类构造函数的函数体。
调用基类构造函数的顺序是按照声明派生类时基类出现的顺序。
例：声明一个教师(Teacher)类和一个学生(Student)类，用多重继承的

方式声明一个研究生(Graduate)派生类。

#include <iostream>
#include <string>
using namespace std;
class Teacher//声明类Teacher(教师) 
{public: //公用部分 
 Teacher(string nam,int a, string t) //构造函数
 {name=nam;
  age=a;
  title=t;} 
 void display( ) //输出教师有关数据 
 {cout<<″name:″<<name<<endl;
  cout<<″age″<<age<<endl;
  cout<<″title:″<<title<<endl; }
 protected: //保护部分 
 string name;
 int age;
 string title; //职称
};
class Student //定义类Student(学生)
{public: Student(char nam[],char s,float sco)
{strcpy(name1,nam);
 sex=s;
 score=sco;} //构造函数 
 void display1( ) //输出学生有关数据 
 {cout<<″name:″<<name1<<endl;
  cout<<″sex:″<<sex<<endl;
  cout<<″score:″<<score<<endl; }
 protected: //保护部分 
 string name1;
 char sex;
 float score; //成绩
};
class Graduate:public Teacher,public Student //声明多重继承的派生类 Graduate 
{public: Graduate(string nam,int a,char s, string t,float sco,float w): Teacher(nam,a,t),Student(nam,s,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″,24,′f′,″assistant″,89.5,1234.5);
 grad1.show( ); 
 return 0;
}

在多重继承时，从不同的基类中会继承一些**重复的数据**
- 解决方法: 在两个基类中可以都使用同一个数据成员名name，而在**引 **

用数据成员时指明其作用域**，如：**

cout<<″name:″<<Teacher::name<<endl;

3.多重继承引起的二义性问题

如果类A和类B中都有成员函数display和数据成员a，类C是类A和类B的直接派生类。
- 讨论下列3种情况:
  - 两个基类有同名成员。
  - 两个基类和派生类三者都有同名成员。
  - 类A和类B是从同一个基类派生的。
两个基类有同名成员

class A
{public:
 int a; 
 void display( );
};
class B
{public: 
 int a;
 void display( );
};
class C :public A,public B
{public : 
int b;
void show();
};

在main函数中

可以用基类名来限定:

c1.A::a=3;//引用c1对象中的基类A的数据成员a
c1.A::display(); //调用c1对象中的基类A的成员函数display

如果是在派生类C中通过派生类成员函数show访问基类A

的display和a，可以不必写对象名而直接写

void C::show( ){
    A::a=3;//指当前对象
    A::display( );}

两个基类和派生类三者都有同名成员。
```
class C :public A,public B
{int a;
void display();
};
```
- 在main函数中
```
C c1;
c1.a=3;
c1.display( );
```
  - 基类的同名成员在派生类中被屏蔽，成为“不可见”的，派生类新增加的同名成员覆盖了基类中的同名成员。
  - 不同的成员函数，只有在函数名和参数个数相同、类型相匹配的情况下才发生同名覆盖，否则为函数重载。
  - 要在派生类外访问基类A中的成员，应指明作用域A:
```
c1.A::a=3;
c1.A::display();
```
如果类A和类B是从同一个基类派生的

class N 
{public:
 int a;
 void display()
 {cout<<″A::a=”<<a<<endl;}
};
class A:public N 
{public: 
int a1;
};
class B:public N 
{public: 
int a2;
};
class C :public A,public B 
{public : 
int a3; 
void show( ) 
{cout<<″a3=″<<a3<<endl;}
};
int main( )
{C c1;//定义C类对象c1 
 ┆
 }

怎样才能访问类A中从基类N继承下来的成员呢？
```
c1.a=3; c1.display( ); 或c1.N::a=3; c1.N::display(); //ERROR
```
- 应当通过类N的直接派生类名来指出要访问的是类N的哪一个派生类中的基类成员。
```
c1.A::a=3; c1.A::display();
```

4.虚基类

虚基类的作用:C++提供虚基类(virtual base class)的方法，**使得在继承间接共同基类时只保留一份成员**。
声明虚基类的一般形式：**class 派生类名: virtual 继承方式基类名**
- 虚基类并不是在声明基类时声明的，而是在声明派生类时，**指定继承方式时声明**的。
- 声明虚基类后，当基类通过多条派生路径被一个派生类继承时，该**派生类只继承该基类一次**
- 为了保证虚基类在派生类中只继承一次，应当在该基类的**所有直接派生类中声明为虚基类。否则仍然会出现对基类的多次继承。**

虚基类的初始化
- 例：
```
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(),B(n),C(n){ }
…};
```
- 如果在虚基类中定义了带参数的构造函数，而且没有定义默认构造函数，则在其所有派生类中，通过**构造函数的初始化表对虚基类进行初始化**。
- 在定义类D的构造函数时，在最后的派生类中不仅要负责对其直接基类进行初始化，还要**负责对虚基类初始化**。
- C++编译系统只执行**最后的派生类对虚基类的构造函数的调用**，而忽略虚基类的其他派生类(如类B和类C) 对虚基类的构造函数的调用，这就保证了虚基类的数据成员不会被多次初始化。

例：在Teacher类和Student类之上增加一个共同的基类Person，作为人员的一些基本数据都放在Person中，在Teacher类和Student类中再增加一些必要的数据。

#include <iostream> 
#include <string>
using namespace std;
class Person //声明公共基类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; //职称 
};
class Student:virtual public Person 
{public:
Student(string nam,char s,int a,float sco) //构造函数 
:Person(nam,s,a),score(sco){ } //初始化表 
protected: //保护成员
float score; //成绩 
};
class Graduate:public Teacher,public 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; 
}

不提倡在程序中使用多重继承，能用单继承解决的问题就不要使用多重继承，只有在比较简单和不易出现二义性的情况或实在必要时才使用多重继承。