多重继承——《C++编程风格》读书笔记（七）
当我们希望在类之间对多个“是一种”(is-a)的关系进行建模时需要用到多重继承，例如，一艘游艇(houseboat)既是一条船(boat)，也可以是一座房子(houseboat)。然而多重继承很难以被高效的使用；多重继承机制有时带来的作用也是有限的。分清什么时候需要用到多重继承，什么时候不要，也是一个难点。
1.多重继承的二义性
程序1 带有二义性的多重继承示例
class Base1{ //.... public: void f(); void g(); //.... }; class Base2{ //.... public: void f(); void h(); //.... }; class Derived:public Base1,public Base2{ //.... };
基类成员函数Base1::g()和Base2::h()都是没有二义性的。当我们通过Derived对象来调用这两个函数时，对于每个函数也都只有一种解释：
Derived d;
d.g(); // unambiguous
d.g(); //unambiguous
但如果试图在Derived对象上调用f(),将会引发编译期的二义性错误：
d.g() //compile-time error
由于函数有着同样的名字而在类中产生二义性，无论这些函数是否是公有成员函数，结果都是一样的。例如，如果一个基类的私有成员和另一基类的公有成员有着同样的名字，也将会产生二义性。也就是说，访问控制并不会影响编译器在作用域规则下对标识符的搜索方式。
程序2 访问控制并不能解读二义性
class Base1{ //.... public: void f(); void g(); //.... }; class Base2{ void f(); //.... public: void h(); //.... }; class Derived:public Base1,public Base2{ //.... }; int main() { Derived d; d.f();//compile-time errorr:ambiguous f //... return 0; }
2.有向无环继承图
在单重继承下，继承层次结构通常可以用类的树状图来描述；在多重继承下，我们需要使用有向无环图(directed acyclic graph)。“有向”意味着所画图中的每条边都有一个方向，用来区分哪一端是基类，哪一端是派生类。我们可以在画图时约定，基类总是出现在派生类的上方。“无环”意味着继承图中没有循环，这样，一个类就永远也不会成为自己的基类，即使间接的也不行。
程序3 共同的基类
class Top { int x; //... }; class Left:public Top { int y; //... }; class Bottom:public Left,public Right { //... };
对程序3中类的结构进行研究可知：
- 派生类中的对象都包含每个基类的所有成员。因此Bottom包含两个Top部分，它可以通过两种不同的途径到达top部分，这就产生了一个潜在的二义性。
- 在默认的继承机制(public)中,所有从基类继承而来的数据成员都保持着独立的副本。
- 当Top作为Left和Right的虚基类(virtual base class)时，Bottom对象只包含一个Top部分，虚基类使得在每个派生类对象中只有唯一的基类部分。(在基类名字前加virtual和在类的成员函数前加virtual是不相干的)。
3. 分析虚基类
将程序3的代码补充完整，并添加一些方便我们分析的语句。首先将Top作为非虚基类，然后再将Top做为虚基类。
程序4 在非虚基类下的赋值运算
#include <iostream> using namespace std; void trace(const char *funcName,void *objAddr) { cout<< "/t" << objAddr << " " << funcName << "/n"; } class Top { int x; public: Top & operator = (const Top&); }; Top& Top::operator=(const Top& rhs) { trace("Top::operator=",this); if(this != &rhs) x = rhs.x; return *this; } class Left:public Top { int y; public: Left& operator=(const Left&); }; Left& Left::operator=(const Left& rhs) { trace("Left::operator=",this); if(this != &rhs) { this->Top::operator=(rhs); y = rhs.y; } return *this; } class Right:public Top { int z; public: Right& operator=(const Right& ); }; Right& Right::operator=(const Right& rhs) { trace("Right::operator=",this); if(this != &rhs) { this->Top::operator=(rhs); z = rhs.z; } return *this; } class Bottom:public Left,public Right { }; int main() { Left L1,L2; Right R1,R2; Bottom B1,B2; cout << "Left object assignment/n"; L1 = L2; cout << "Right object assignment/n"; R1 = R2; cout << "Bottom object assignment/n"; B1 = B2; return 0; }
运行结果：
Left object assignment
0012FF78 Left::operator=
0012FF78 Top::operator=
Right object assignment
0012FF68 Right::operator=
0012FF68 Top::operator=
Bottom object assignment
0012FF50 Left::operator=
0012FF50 Top::operator=
0012FF58 Right::operator=
0012FF58 Top::operator=
在Left和Right对象的赋值运算中，程序调用了Top::operator=来对派生类对象中的Top部分进行赋值。而对于在Bottom对象的赋值运算中，由于Bottom类并没有定义自己的operator=,因此调用编译器默认生成的Bottom::operator=，在编译器生成的Bottom::operator=中，将依次调用Left::operator=和Right::operator=对Bottom对象的Left部分和Right部分进行赋值，同时对其Top部分重复进行了两次相同的赋值。
程序5 虚基类下的赋值运算
#include <iostream> using namespace std; void trace(const char *funcName,void *objAddr) { cout<< "/t" << objAddr << " " << funcName << "/n"; } class Top { int x; public: Top & operator = (const Top&); }; Top& Top::operator=(const Top& rhs) { trace("Top::operator=",this); if(this != &rhs) x = rhs.x; return *this; } class Left:public virtual Top { int y; public: Left& operator=(const Left&); }; Left& Left::operator=(const Left& rhs) { trace("Left::operator=",this); if(this != &rhs) { this->Top::operator=(rhs); y = rhs.y; } return *this; } class Right:public virtual Top { int z; public: Right& operator=(const Right& ); }; Right& Right::operator=(const Right& rhs) { trace("Right::operator=",this); if(this != &rhs) { this->Top::operator=(rhs); z = rhs.z; } return *this; } class Bottom:public Left,public Right { }; int main() { Left L1,L2; Right R1,R2; Bottom B1,B2; cout << "Left object assignment/n"; L1 = L2; cout << "Right object assignment/n"; R1 = R2; cout << "Bottom object assignment/n"; B1 = B2; return 0; }
运行结果：
Left object assignment
0x22ff44 Left::operator=
0x22ff4c Top::operator=
Right object assignment
0x22ff2c Right::operator=
0x22ff34 Top::operator=
Bottom object assignment
0x22ff0c Left::operator=
0x22ff1c Top::operator=
0x22ff14 Right::operator=
0x22ff1c Top::operator=
观察结果并分析：程序5使用虚基类Top的唯一好处是每个Bottom对象只有一个Top部分，但是仍然不能解决Top部分重复进行两次相同赋值的问题。分析发现，在Left部分和Right部分的operator=中必须调用Top::operator=，因此对于Left对象和Right对象来说，所进行的赋值运算都是正确的。其中一个解决方案就是在Left和Right中增加一个赋值成员函数。它所执行的工作只是对类的自身的成员进行赋值，而不会去调用虚基类的operator=。命名为assignLocal。于是，我们就可以在Bottom对象中引入Bottom::operator=以提供不重复的赋值行为，而不是用编译器默认的赋值函数。
程序6 改进的虚基类下的赋值运算
#include <iostream> using namespace std; void trace(const char *funcName,void *objAddr) { cout<< "/t" << objAddr << " " << funcName << "/n"; } class Top { int x; public: Top & operator = (const Top&); }; Top& Top::operator=(const Top& rhs) { trace("Top::operator=",this); if(this != &rhs) x = rhs.x; return *this; } class Left:public virtual Top { int y; protected: void assignLocal(const Left& rhs); public: Left & operator=(const Left &); }; void Left::assignLocal(const Left& rhs) { trace("Left::assignLocal",this); y = rhs.y; } Left& Left::operator=(const Left& rhs) { trace("Left::operator=",this); if(this != &rhs) { this->Top::operator=(rhs); assignLocal(rhs); } return *this; } class Right:public virtual Top { int z; protected: void assignLocal(const Right&); public: Right& operator=(const Right& ); }; void Right::assignLocal(const Right& rhs) { trace("Right::assignLocal",this); z = rhs.z; } Right& Right::operator=(const Right& rhs) { trace("Right::operator=",this); if(this != &rhs) { this->Top::operator=(rhs); assignLocal(rhs); } return *this; } class Bottom:public Left,public Right { public: Bottom & operator=(const Bottom &); }; Bottom & Bottom::operator=(const Bottom &rhs) { trace("Bottom::operator=",this); if(this != &rhs) { Top::operator=(rhs); Left::assignLocal(rhs); Right::assignLocal(rhs); } return *this; } int main() { Left L1,L2; Right R1,R2; Bottom B1,B2; cout << "Left object assignment/n"; L1 = L2; cout << "Right object assignment/n"; R1 = R2; cout << "Bottom object assignment/n"; B1 = B2; return 0; }
运行结果：
Left object assignment
0012FF74 Left::operator=
0012FF7C Top::operator=
0012FF74 Left::assignLocal
Right object assignment
0012FF5C Right::operator=
0012FF64 Top::operator=
0012FF5C Right::assignLocal
Bottom object assignment
0012FF3C Bottom::operator=
0012FF4C Top::operator=
0012FF3C Left::assignLocal
0012FF44 Right::assignLocal
现在，Bottom对象的赋值运算中，Top::operator=只会执行一次了。
4. 使用虚基类
我们设计了一个继承层次：基类DomesticAnimal(家畜)，类Cow(母牛)和Buffalo(水牛)派生于类DomesticAnimal，而类Beefalo(一种由肉用黄牛与北美洲野牛杂交而成的肉用牛,叫做皮弗娄牛)是从Cow和Buffalo派生出来的。
程序7 DomesticAnimal、Cow、Buffalo和Beefalo
#include <stdlib.h> #include <iostream> using namespace std; class DomesticAnimal { protected: int weight; float price; char color[20]; public: DomesticAnimal(void) { weight = 0; price = 0; strcpy(color,"None"); } DomesticAnimal(int aWeight,float aPrice,char *aColor) { weight = aWeight; price = aPrice; strcpy(color,aColor); } virtual void print(void) { cout << "The weight = " << weight << "/n"; cout << "The price = $" << price << "/n"; cout << "The color = " << color << "/n"; } }; class Cow:public virtual DomesticAnimal { public: Cow(void) { } Cow(int aWeight,float aPrice,char *aColor) { weight = aWeight; price = aPrice; strcpy(color,aColor); } void print(void) { cout << "The cow has the properties:/n"; DomesticAnimal::print(); } }; class Buffalo:public virtual DomesticAnimal { public: Buffalo(void) { } Buffalo(int aWeight,float aPrice,char *aColor) { weight = aWeight; price = aPrice; strcpy(color,aColor); } void print(void) { cout << "The Buffalo has the properties:/n"; DomesticAnimal::print(); } }; class Beefalo:public Cow,public Buffalo { public: Beefalo(int aWeight,float aPrice,char *aColor) { weight = aWeight; price = aPrice; strcpy(color,aColor); } void print(void) { cout << "The Beefalo has the properties:/n"; DomesticAnimal::print(); } }; int main() { Cow aCow(1400,375.0,"Black and white"); Beefalo aBeefalo(1700,525.0,"Brown and black"); DomesticAnimal& myCow = aCow; DomesticAnimal& myBeefalo = aBeefalo; myCow.print(); myBeefalo.print(); aBeefalo.Cow::print();//Beefalo对象也可以被认为是一个Cow对象 return 0; }
运行结果：
The cow has the properties:
The weight = 1400
The price = $375
The color = Black and white
The Beefalo has the properties:
The weight = 1700
The price = $525
The color = Brown and black
The cow has the properties:
The weight = 1700
The price = $525
The color = Brown and black
程序分析：DomesticAnimal是有意义的，Cow和Buffalo都是DomesticAnimal的特化形式。然而，在继承关系中存在着一个缺陷：Cow和Buffalo都是Beefalo的基类，若b是一个Beefalo对象，那么b.Cow::print()将是合法的函数调用，这表示Beefalo对象也可被认为是一个Cow对象。除了能够使Beefalo对象通过显式地调用基类虚函数来伪装身份外，将Beefalo从Cow继承下来没有其他的作用，因此，我们可以将Beefalo直接从DomesticAnimal中继承下来。
程序8 去掉虚基类
#include <stdlib.h> #include <iostream> using namespace std; class DomesticAnimal { int weight; float price; char color[20]; public: DomesticAnimal(void) { weight = 0; price = 0; strcpy(color,"None"); } DomesticAnimal(int aWeight,float aPrice,char *aColor) { weight = aWeight; price = aPrice; strcpy(color,aColor); } virtual void print(void) { cout << "The weight = " << weight << "/n"; cout << "The price = $" << price << "/n"; cout << "The color = " << color << "/n"; } }; class Cow:public DomesticAnimal { public: Cow(int aWeight,float aPrice,char *aColor) : DomesticAnimal(aWeight,aPrice,aColor) {} void print(void) { cout << "The cow has the properties:/n"; DomesticAnimal::print(); } }; class Buffalo:public DomesticAnimal { public: Buffalo(int aWeight,float aPrice,char *aColor) : DomesticAnimal(aWeight,aPrice,aColor) {} void print(void) { cout << "The Buffalo has the properties:/n"; DomesticAnimal::print(); } }; class Beefalo:public DomesticAnimal { public: Beefalo(int aWeight,float aPrice,char *aColor) : DomesticAnimal(aWeight,aPrice,aColor) {} void print(void) { cout << "The Beefalo has the properties:/n"; DomesticAnimal::print(); } }; int main() { Cow aCow(1400,375.0,"Black and white"); Beefalo aBeefalo(1700,525.0,"Brown and black"); DomesticAnimal& myCow = aCow; DomesticAnimal& myBeefalo = aBeefalo; myCow.print(); myBeefalo.print(); return 0; }
生物学上的继承和C++中的继承有着重要的区别：生物学上的后代从它们的父母双方中“继承”特征，但这并不意味着在程序设计中，类继承就是对这种关系建模的好方法。如果用继承来对繁殖关系进行建模，那么我们就需要使每个对象都成为一个类，并且这个类只能被实例化一次。程序7就是由于没理解这两者的关系编写而成的。
对于生物学上的继承，更好的模型是将每个物种都作为一个类，而每个动物都是从物种类中实例化出来的对象。后代对象则可以通过基因信息来进行初始化，其中这个基因信息时期父母基因信息的组合。在软件中对生物学上的继承关系进行建模时，它所对应的应该是对象与对象的关系，而不是类与类的关系。
参考文献：《c++编程风格》（c++ programming style ）作者 Tom Cargill 译者 聂雪军 机械工业出版社2007.1