Object-Oriented

Programming

in C++

第五章 继承与派生

中国科大学继续教育学院 李艺leeyi@ustc.edu.cn

C++ 5- 2

第一章 C++ 的初步知识第二章 类和对象第三章 再论类和对象第四章 运算符重载第五章 继承与派生第六章 多态性与虚函数第七章 输入输出流第八章 C++ 工具

C++ 5- 3

5.1 继承与派生的概念5.2 派生类的声明方式5.3 派生类的构成5.4 派生类成员的访问属性

5.5 派生类的构造函数和析构函数5.6 多重继承5.7 基类与派生类的转换5.8 继承与组合

C++ 5- 4

5.1 继承与派生的概念我们知道，面向对象程序设计的 4 个特性有抽象、封

装、继承和多态。我们已经讨论了数据的抽象性和封装性，现在来讨论数据的继承。

C++ 5- 5

5.1 继承与派生的概念所谓继承，就是根据一个已存在的类建立一个新的类。

已存在的类叫“基类”或“父类”，新建立的类叫“派生类”或“子类”。

新建立的子类从基类那里获得基类的特性，称为类的继承；由基类产生新的子类，叫派生。一个基类可以派生多个子类，一个子类可以由多级基类派生而来。比如：

大学学生

大学生 研究生

大专生 本科生 博士生硕士生

一个基类派生多级子类示意图约定：箭头方向表示继承的方向，由派生类指向基类。

C++ 5- 6

5.1 继承与派生的概念多个基类派生一个子类示意图。约定：箭头方向表示继承的

方向，由派生类指向基类。

研究生 职工

在职研究生

基类：

派生类：

C++ 5- 7

5.2 派生类的声明方式声明派生类的方法：

class 派生类名： [ 继承方式 ] 基类名{ 派生类新增的成员} ；

继承方式包括：Public 方式，公用方式；Private 方式，私有方式；Protected 方式，受保护方式。继承方式是可选的，不写此项，默认为私有方式。

C++ 5- 8

5.2 派生类的声明方式例如，由一基类 Box （盒子类），派生出一个新的子类

colorBox （彩色盒子）：

#include <iostream.h>class Box{private: int len,wid,hei;public: void display( ) { cout<<“ 盒子体积 =” <<len*wid*hei<<endl; } Box (int l=0, int w=0, int h=0) { len = l; wid = w; hei = h; }};

class colorBox : public Box{ private: int color;public: void display( ) {cout<<“ 盒子的颜色 =” << color << endl; } colorBox (int c=0) {color = c; }};void main( ){ colorBox cb1(3); cb1.display( );}

C++ 5- 9

colorBox 类

int len;

int wid;

int hei;

构造函数 Box;

void display( );

int color;

void display( );

Box 类

int len;

int wid;

int hei;

构造函数 Box;

void display( );

5.3 派生类的构成派生类的成员包括从基类继承过来的成员和自己增加

的成员。从基类继承过来的成员，体现了基类与子类的共性；而新增加的成员，体现了子类的个性。下面是 Box 基类和 colorBox 子类的存储图：

基类

数据成

员

成员函数

派生类

新增成

员

继承

C++ 5- 10

5.3 派生类的构成请注意，类的继承并不是把基类成员和派生类新增成员简单

地放在一起。构造一个派生类包括以下四部分工作 从基类接收成员。派生类把基类的全部成员（不包括构造函数和析

构函数）接收过来。不足之处在于会造成冗余，浪费存储空间和执行效率，尤其是多次派生时。所以，不能随意地找一个类去派生出某一个子类。

调整从基类接收的成员。接收基类成员必须照单全收，但编程人员可以对接收过来的成员作一些调整。如，通过指定不同的继承方式，来改变基类成员在派生类中的访问属性；

在派生类中声明一个和基类成员同名的成员，来“遮盖”接收的基类成员。如果想遮盖成员函数，其函数名和参数表必须相同，否则就成为重载。

在声明派生类时增加新的成员。主要体现子类对基类的扩展。 构造派生类的构造函数和析构函数。

C++ 5- 11

5.4 派生类成员的访问属性派生类成员中包含基类成员和派生类成员 , 在讨论访问

属性时 , 需要考虑以下几种情况 :

① 基类成员函数访问基类成员 ;

② 派生类成员函数访问派生类自己新增成员 ;

③ 基类成员函数访问派生类成员 ;

④ 派生类成员函数访问基类成员 ;

⑤ 在派生类外访问派生类的成员 ;

⑥ 在派生类外访问基类的成员。对于①、②，种情况，按照第二章介绍的规则处理。

即基类成员函数可访问基类成员，派生类成员函数可访问派生类自己新增成员，基类私有数据成员只能被基类成员函数访问，派生类新增私有数据成员，只能被派生类新增成员函数访问。

C++ 5- 12

5.4 派生类成员的访问属性对于第④ ~⑥ 种情况，我们分不同的继承方式分开讨论：

公用继承：基类的公用成员和保护成员在派生类中保持原有的访问属性，其私有成员仍为基类的私有，派生类新增成员不可访问它。

私有继承：基类的公用成员和保护成员在派生类中成为私有成员，其私有成员仍为基类的私有，派生类新增成员不可访问它。

保护继承：基类的公用成员和保护成员在派生类中成为保护成员，其私有成员仍为基类的私有，派生类新增成员不可访问它。

什么叫保护成员？保护成员不能被外界引用，但可以被派生类的成员引用。

C++ 5- 13

5.4 派生类成员的访问属性公用继承

公用继承的定义：在定义一个派生类时，将基类的继承方式指定为 public 就是公用继承。其基类叫公用基类 ( public

base class), 子类叫公用派生类 ( public derived class) 。被公用继承而来的基类在派生类中的访问属性见下表：

我们来看看下面的示例程序：

公用基类的成员 在公用派生类中的访问属性

私有成员 不可访问

公用成员 公用

保护成员 私有

C++ 5- 14

5.4 派生类成员的访问属性#include <iostream.h>#include <string.h>class person{public: void get_value( ) { cin>>num>>name; } void display( ) { cout<<“id:”<<num<<endl; cout<<“name:”<<name<<endl; }private: int id; string name;};class student : public person{public: void display( ) {cout<<“id:”<<num<<endl; // 错误 , 派生类中不能访问基类私有成员 cout<<“name:”<<name<<endl; // 错误 , 派生类中不能访问基类私有成员 cout<<“stu_id:”<<stu_id<<endl; }private: int stu_id;};

C++ 5- 15

程序应修改 ,在main 函数中分别调用基类和派生类的显示成员函数 :

#include <iostream.h>#include <string.h>class person{public: void get_value( ) { cin>>num>>name; } void person_display( ) { cout<<“id:”<<num<<endl; cout<<“name:” <<name<<endl; }private: int id; string name;};class student : public person{public: void student_display( ) { cout<<“stu_id:” <<stu_id<<endl; }private: int stu_id;};

void main( ){ student zhangsan; : : : zhangsan.person_display( ); zhangsan.student_display( );}

这里只是对显示函数做了调整 , 其实还有很多修改 . 比如 ,对数据输入 , 就要调整 . 请同学们自己完成 .

C++ 5- 16

5.4 派生类成员的访问属性私有继承

私有继承的定义：在定义一个派生类时，将基类的继承方式指定为 private 就是私有继承。其基类叫私有基类( privatepublic base class), 子类叫私有派生类 ( private

derived class) 。被私有继承而来的基类在派生类中的访问属性见下表：

我们来看看下面的示例程序：

私有基类的成员 在私有派生类中的访问属性私有成员 不可访问

公用成员 私有

保护成员 私有

C++ 5- 17

5.4 派生类成员的访问属性我们作如下示意图来说明私有继承的访问属性 :

子类 B

public:

int m;

private:

int i,n;

不可访问 :

int k ;

基类 A

public:

int i;

private:

int k;

子类 B

public:

int i;

private:

int k;

public:

int m;

private:

int n;

私有继承

派生类新增成员

实际派生类

基类 A 中的公用成员 i ，私有成员 k ，被私有派生给子类 B 子类 B 自己新增公用成员 m ，和私有成员 n最后，子类 B 具有的公用成员为 m ，私有成员为 i, n 。基类的 k

在子类 B 中不可访问。

C++ 5- 18

私有继承示例：这里的错误该如何改写？

#include <iostream.h>#include <string.h>class person{public: void get_value( ) { cin>>num>>name; } void person_display( ) { cout<<“id:”<<num<<endl; cout<<“name:” <<name<<endl; }private: int id; string name;};class student : private person{public: void student_display( ) { cout<<“stu_id:” <<stu_id<<endl; }private: int stu_id;};

void main( ){ student zhangsan; : : : zhangsan.person_display( ); // 私有继承基类的公用函数 // 变成子类私有函数，类外不能访问 zhangsan.student_display( );}

C++ 5- 19

可以将子类的显示函数这样改写：

#include <iostream.h>#include <string.h>class person{public: void get_value( ) { cin>>num>>name; } void person_display( ) { cout<<“id:”<<num<<endl; cout<<“name:” <<name<<endl; }private: int id; string name;};

class student : private person{public: void student_display( ) { person_display( ); cout<<“stu_id:” <<stu_id<<endl; }private: int stu_id; };void main( ){ student zhangsan; : zhangsan.student_display( );}

C++ 5- 20

5.4 派生类成员的访问属性 保护成员和保护继承

“ 保护 ,protected”既可以用来限定类成员的性质，也可以用来限定继承方式。 保护成员：被 protected 声明的成员叫保护成员，保护成员不能被类外访问，这和私有成员的特性一样；但保护成员如果被派生给子类，可以被子类的成员函数引用。

我们将友元比喻成朋友，可以进入自己的卧室，访问类的私有成员；我们将保护成员比喻成保险箱，任何外人不得窥视，包括朋友。只有自己和子女（即派生类）可以打开。 保护继承：派生类继承时被指定为 protected 。用保护方式继承的

派生类叫保护派生类 ( protected detived class), 其基类叫受保护的基类 ( protected bass class ) 。

保护继承的特点是，保护基类的公用成员和和保护成员在保护派生类中成为保护成员，私有成员仍为基类私有，派生类不得引用。

C++ 5- 21

5.4 派生类成员的访问属性综合所述，三种继承方式下派生类成员的访问属性列表如下：

基类中的成员属性

在公用继承得来的派生类中

在私有继承得来的派生类中

在保护继承得来的派生类中

私有成员 不可访问 不可访问 不可访问

公用成员 公用 私有 保护

保护成员 保护 私有 保护

由上表可以得出以下结论： 公用成员，派生类内外都可以访问； 保护成员，派生类内可以访问，派生类外不能访问，其下一级的派生也可以访问；

私有成员，派生类内可以访问，派生类外不能访问，其下一级的派生不可访问；

不可访问的成员，派生类内外都不可访问。

C++ 5- 22

5.4 派生类成员的访问属性 下面是一个怎样使用保护成员的示例：

#include <iostream.h>#include <string.h>class person{protected: int id; string name;};class student : protected person{public: void student_display( ) { cout<<“id:”<<id<<endl; cout<<“name:”<<name<<endl; cout<<“stu_id:” <<stu_id<<endl; }private: int stu_id; };void main( ){ student zhangsan; student.id=“12345678; //错误，外界不能访问保护成员 zhangsan.student_display( ); // 合法，此函数是公用函数}

C++ 5- 23

5.4 派生类成员的访问属性 多级派生时的访问属性

实际应用中，常常有多级派生的情况。比如： A 是基类，派生出 B类， B 类又派生出 C 类。则 B 是 A 的直接派生， C 是 A 的间接派生。 A 是B 的直接基类， A 是 C 的间接基类。请看：

A 是 B 的公用基类， B 是 C 的保护基类；各成员在不同类的属性为：

class A{public: int i;protected: int j; void f2( );private: int k; };

class B : public A{public: void f3( );protected: void f4( );private: int m;};

class C : protected B{public: void f5( );private: int n;};

i f2 j k f3 f4 m f5 n

基类 A 公用 保护 保护 私有公用派生类 B 公用 保护 保护

不可访问 公用 保护 私有

保护派生类 C 保护 保护 保护

不可访问 保护 保护

不可访问 公用 私有

C++ 5- 24

5.4 派生类成员的访问属性上表说明：

无论哪一种继承方式，在派生类中不能访问基类的私有成员，私有成员只能被本类的成员函数访问；

多级派生若都采用公用继承，直到最后一级派生类都能访问基类的公用成员和保护成员；

多级派生若都采用私有继承，经过若干次派生后，基类的所有成员都变成不可访问；

多级派生若都采用保护继承，派生类外无法访问派生类中的任何成员，人们很难记住哪些成员还能访问，哪些成员不能被访问。

因此，实际应用中，通常采用公用继承方式。

C++ 5- 25

5.5 派生类的构造函数和析构函数构造函数的主要作用是对数据成员初始化。在第三章

我们介绍过，用户在声明类时可以不定义构造函数，系统会自动设置一个默认的构造函数，在定义类对象时会自动调用这个默认的构造函数。这个默认的构造函数实际上是个空函数，不执行任何操作，如果需要初始化对象的数据成员，应该自己定义构造函数。

我们已经知道，基类的构造函数是不能继承的。因此，对继承来的基类成员初始化的工作，要由派生类的构造函数承担。所以，在设计派生类的构造函数时，不仅要考虑初始化派生类自己新增的数据成员，还要考虑初始化基类的数据成员。

解决问题的思路是：在执行派生类的构造函数时，调用基类的构造函数。

C++ 5- 26

5.5 派生类的构造函数和析构函数简单派生类的构造函数

我们说的“简单”是指，一个基类直接派生出一个子类，派生类的数据成员中不包含基类的对象（即子类）。

简单派生类的构造函数一般形式

派生类构造函数名 (总参数表列 ) : 基类构造函数名 ( 参数表列 )

{ 派生类中新增数据成员初始化语句 }

下面以一个派生类的实例来说明有些什么东西。

C++ 5- 27

5.5 派生类的构造函数和析构函数#include <iostream.h>#include <string.h>class person // 基类声明{public: person (int i, string nam) // 基类构造函数 { id = i; name = nam; }protected: int id; string name;};class student : public person // 声明公用派生类{ public: student( int i, string nam, int sid) : person( i, nam) { stuid = sid; } // 子类构造函数 void show( ) {cout<<“id:”<<id<<endl; cout<<“name:”<<name<<endl; cout<<“stuid:”<<stuid<<endl; }private: int stuid;};void main( ){ student s1(1234,”张三” ,200701); s1.show( );}

C++ 5- 28

5.5 派生类的构造函数和析构函数将派生类的构造函数形式与第三章介绍的“用参数初

始化表对数据成员初始化”的介绍，对照看看： student( int i, string nam, int sid) : person( i, nam) { stuid = sid; }

box::box(int h, int w, int len): height (h), width (w), length (len) { }

它也有一个冒号，在冒号后面是对数据成员的初始化表。很相似吧？

实际上，本章介绍的在派生类构造函数中对基类成员初始化，就是第三章介绍的构造函数初始化表。也就是说：不仅可以用初始化表对数据成员初始化，而且可以利用初始化表调用派生类的基类构造函数，实现

对基类数据成员的初始化。也可以在同一个构造函数中同时实现这两种功能。

C++ 5- 29

5.5 派生类的构造函数和析构函数例如，我们可以将上一个示例的子类构造函数改写成这样：student( int i, string nam, int sid) :

person( i, nam) ， stuid(sid) { }

这样，函数体为空，显得很简捷，方便。

在建立一个对象时，执行构造函数的顺序是：先调用基类构造函数；再执行派生类自身的构造函数。

对于刚才的示例，先初始化 id,name ，再初始化 stuid 。

C++ 5- 30

5.5 派生类的构造函数和析构函数有子对象的派生类的构造函数

如果类的数据成员除了标准数据类型外，还包含类对象，这种被包含的对象就叫“子对象 ( subobject ) ，即对象中的对象。

我们仍以学生类为示例。在 person 的派生类 student

中，出来增加学号 stuid ，还增加“家长 parent” 一项，即学生数据中包含他的家长姓名等相关情况，而家长本身也属于 person 类型，这样，家长 parent 项既是基类 person 对象，也派生类 student 的子对象。

那么，初始化子类对象的数据成员时，这样对它所包含的子对象初始化呢？这是我们所关心的问题。请看下面程序：

C++ 5- 31

5.5 派生类的构造函数和析构函数#include <iostream.h>#include <string.h>class person{public: person (int i, string nam) { id = i; name = nam; } void display( ) { cout<<“id:”<<id<<endl; cout<<“name:”<<name<<endl; }protected: int id; string name;};class student : public person { public: student( int i, string nam, int pid, string pnam, int sid) : person( i, nam),parent(pid,pnam) { stuid = sid; } 派生类构造函数任务： 1 ，初始化基类

数据成员； 2 ，初始化子对象数据成员；3 ，初始化派生类新增数据成员。

void show( ) {cout<<“id:”<<id<<endl; cout<<“name:”<<name<<endl; cout<<“stuid:”<<stuid<<endl; }void showParent( ) {cout<<“parent_id:”<<endl; parent.display( ); }private: int stuid; person parent;};void main( ){ student s1(1234,”张三” , 2211,”张父” ,200701); s1.show( ); s1.showParent( );}

C++ 5- 32

5.5 派生类的构造函数和析构函数归纳起来，我们有

派生类构造函数的一般形式：派生类构造函数名 (总参数表 ):

基类构造函数名 ( 参数表列 ) ，子对象名 ( 参数表列 ) ，{ 派生类中新增数据数据成员初始化语句 }

执行派生类构造函数的顺序：① 调用基类构造函数，初始化基类数据成员；② 调用子对象构造函数，初始化子对象数据成员；③ 再执行派生类自身的构造函数，初始化自己新增数据成

员。

C++ 5- 33

5.5 派生类的构造函数和析构函数上例中的 student 派生类构造函数可写成如下形式：student( int i, string nam, int pid, string pnam, int sid ) :

person ( i, nam),

parent (pid,pnam),

stuid ( sid ) { }

可以看到，函数体为空。此时，派生类构造函数参数个数等于基类构造函数参数、子对象构造函数参数、自己新增数据对象初始化参数之和。这种形式十分常见。

C++ 5- 34

5.5 派生类的构造函数和析构函数 多层派生时的构造函数

当出现多层派生时 , 不能列出每一层的构造函数，只须写出其上一层派生类（即它的直接基类）的构造函数就可以了。

private: int age;};class student2 : public student1{public: student2 (int n, string nam, int a,int s): student1 (n, nam,a) { score = s; } void show_all( ) { show( ); cout<<“age:”<<age<<endl; }private: int score;};

void main( ){ student2 stud(1001,”Li”,17,90); stud.show_all( );}

#include <iostreaam.h>#include <string.h>class student{public: student (int n, string nam) { num = n; name = nam; } void display( ) {cout<<“num:”<<num<<endl; cout<<“name:”<<name<<endl; }private: int num; string name;};class student1 : public student{public: student1 (int n, string nam, int a): student (n, nam) { age = =a; } void show( ) {display ( ); cout<<“age:”<<age<<endl; }

C++ 5- 35

5.5 派生类的构造函数和析构函数程序中，基类 student 构造函数首部为： student ( int n, string nam )

一级派生类 student1 构造函数首部为 student1 ( int n, string nam, int a ):student (n,nam)

二级派生类 student2 构造函数首部为 student2 ( int n, string nam, int a, int s ):

student1 (n,nam,a)

注意，二级派生类 student2 构造函数首部不要写成： student2 ( int n, string nam, int a, int s ):

student (n, nam), student1(n, m, a) //错误！！

不要列出每一层构造函数，只须列出其上一层的构造函数。

C++ 5- 36

5.5 派生类的构造函数和析构函数派生类的析构函数

析构函数的作用：我们已经学过，析构函数的作用是在撤消对象之前，给编程人员一个机会，来进行一些清理工作。当对象被删除时，系统会自动调用析构函数。

和构造函数一样，析构函数也是不能派生给派生类的，在派生类中必须编写自己的析构函数，来作些派生类自己的清理工作。

调用析构函数的顺序：与调用构造函数的顺序正好相反：先执行派生类自己的析构函数，清理派生自己新增数据成员；

再调用子对象的析构函数，清理子对象；最后调用基类的析构函数，对基类进行清理。

C++ 5- 37

5.6 多重继承什么叫多重继承？一个子类由多个基类派生而来，叫多重继

承。比如所，在职研究生，既有在职职工的属性，又有研究生的属性。 C++ 为了适应这种情况，允许一个派生类同时继承多个基类，这种行为就是多重继承 ( multiple inheritance

) 。声明多重继承的方法：设已声明了类 A,B,C ，可以从它们派

生出子类 D ，其声明的一般形式为：class D : public A, private B, protected C

{ 类 D 新增加的成员 }

D 是按照不同的继承方式从不同的基类多重继承而来的派生类。

C++ 5- 38

5.6 多重继承多重继承派生类的构造函数：多重继承派生类的构造函数与

单继承派生类的构造函数基本相同，只是在初始表中包含多个基类构造函数。其一般形式是：

派生类构造函数名 (总参数表 ):

基类 1 构造函数 ( 参数列表 1),

基类 2 构造函数 ( 参数列表 2),

基类 3 构造函数 ( 参数列表 3)

{ 派生类中新增数据成员初始化语句 }

例：分别声明一个职工类 (姓名，工资 ) 和一个研究生类 (

姓名，成绩 ) ，用多重继承的方式从这两个类派生出在职研究生类 ( 新增学号 ) 。在定义派生类时给出初始化数据，然后输出这些数据。

C++ 5- 39

5.6 多重继承#include <iostream>#include <string>using namespace std;class worker{public: worker (string nam, int sal) { name = nam; salary = sal; } void wdisplay( ) {cout<<“name:”<<wname<<endl; cout<<“salary:”<<salary<<endl; }protected: string wname; int salary;};class student{public: student(string snam, int s ) { sname = snam; score = s; } void sdisplay( ) {cout<<“name:”<<sname<<endl; cout<<“score:”<<score<<endl; }protected: string sname; int score;};

class graduate : public worker, public student{public: graduate(string nam,int sal,int s,int i ) : worker (nam, sal), student (nam, s), id(i) { } void gdisplay( ) { cout<<“id:”<<id<<endl; cout<<“wname:”<<name<<endl; cout<<“salary:”<<salary<<endl; cout<<“score:”<<score<<endl; }private: int id;};void main( ){ graduate s1(“Li”, 2000, 90, 1001); s1.gdisplay( );}

C++ 5- 40

5.6 多重继承此例程中，请注意：

① 两个基类的数据成员都声明成 protected 类型，因此可以通过派生类的成员函数引用这两个基类的数据成员。

② 同学们可能注意到，两个基类中，分别用 wname 和sname 来表示姓名，其实是同一个人的姓名，能否用同一名称呢？不行。因为，这样一来，同一个派生类中就有两个同名的数据成员，引起二义性。

③ 多重继承时，从不同的基类中会继承一些重复的数据，例如本例中姓名就是重复的。在实际编程应用中，会有更多的重复数据，问题会更突出。

C++ 5- 41

5.6 多重继承 多重继承的二义性

多重继承给编写程序带来灵活性，但也引出了“二义性 ( ambiguous )” 问题。我们来看看。

若类 A 和类 B 中都有成员函数 display 和数据成员a ，类 C 是 A 、 B 的多重继承的直接派生类。我们下列三种情况讨论：① 两个基类有同名成员，

如右图示。假设 C

类有一对象 c1 ，我们写：c1.a =3;

c1.display( );

A 类int a;

voiddisplay( )

B 类int a;

voiddisplay( )

C 类int a;

voiddisplay( )

int a;

voiddisplay( )

int b;

voidshow( )

基类 A的成员

基类 B的成员

派生类 C新增成员

C++ 5- 42

5.6 多重继承由于基类 A 、 B都有数据成员 a ，和成员函数

display( ), 系统没法判断要访问哪一个基类成员。解决的办法是，在成员名前加上对象名来限制：

c1.A::a = 3;

c1.A::display( );

如果在派生类 C 中，通过成员函数 show( ) 来访问基类的 display( ) 和a ，可以直接写成：

A::a = 3;

A::display( );

C 类int A::a;

voidA::display( )

int B::a;

voidB::display( )

int b;

voidshow( )

基类 A的成员

基类 B的成员

派生类 C新增成员

C++ 5- 43

5.6 多重继承② 两个基类和派生类都有同名成员，则 C 类的成员函数变

为：class C : public A, public B

{ int a;

void display( );

}

在 main 函数中，定义 C 对象为 c1 ，并调用 a 和 dispaly( ) ：C c1;

c1.a =3;

c1,.display( );

这访问的是 C 的成员，因为有规则：基类的同名成员在派生类中被屏蔽。

C 类int A::a;

voidA::display( )

int B::a;

voidB::display( )

int a;

voiddisplay( )

基类 A的成员

基类 B的成员

派生类 C新增成员

C++ 5- 44

5.6 多重继承③ 如果类 A 、 B 是从同一个基类派生的，如下图示：

基类 N 的成员 a 和 display( ) 在一级派生类 A 、 B 中都存在。若要访问 A 类中的 a 和 display( ) ，必须加上类名限定。

类 N

类 A 类 B

类 C

class C : publci A, public B{public: int a3; void show( ) {cout<<“a3:“ <<a3<<endl; }};

void main( ){ C c1; c1.A::a:=3; c1.A::display( );}

class N{public: int a; void display( ) { cout<<“N::a:” <<a<<endl; }};class A : public N{public: int a1;};class B : public N{public: int a2;};

C++ 5- 45

5.6 多重继承虚基类

如果一个派生类有多个直接基类，而这些直接基类又有一个共同的基类，那么在最终的派生类中回保留该间接共同基类数据成员的多份同名成员。前一个示例就是这种情况。

C 类int A::a;int A::a1;int B::a;int B::a2;int a;void A:;display( );void B::display( );void show( );

派生类C 的数据成员

派生类C 的成员函数

基类 N 的成员

A 新增成员

基类 N 的成员

B 新增成员

C 新增成语

N

N

A

B

C

C++ 5- 46

5.6 多重继承在一个类中保留间接共同基类的多份同名成员，虽然

有时是必要的，可以在不同的数据成员中存放不同的数据。但大多数情况下是不必要的，浪费较多内存空间，容易出错。实际上并不需要这么多份拷贝。

C++提供虚基类的技术来解决这仪问题。其解决思路是，在继承间接共同基类时，内存里只存

储一份成员。虚基类定义的一般形式

class 派生类名： virtual 继承方式 基类名即在声明派生类时，将关键字 virtual 加在继承方式

前面。经过这样的声明后，当基类通过多条派生路径被一个派生类中只继承一次，即基类成员只保留一次。

C++ 5- 47

5.6 多重继承

需要注意的是，为了保证虚基类在派生类中只继承一次，应该在该基类的所有直接派生类中声明为虚基类。否则仍然会出现对虚基类的多次继承。

如果象右图那样，只在 A,B

中将 N 声明为虚基类，而 C 中没有将 N 声明为虚基类，则派生类 D

中仍然有冗余的基类拷贝。

类 N

类 A 类 C

类 D

类 B

virtual

virt

ual

C++ 5- 48

5.6 多重继承虚基类的初始化：在最后的派生类中，不仅要初始化直接基类，

而且还要初始化虚基类。如果虚基类中定义了带参数的构造函数，而且没有定义

默认构造函数，则在所有直接派生和间接派生类中通过构造函数的初始化表对虚基类进行初始化。如：

注意，在定义多重继承的派生类 D 时，由于虚基类在派生类中只有一份数据成员，所以这份数据成员的初始化必须由最后的派生类直接给出，以避免出现 B 、 C 的构造函数给出不同的初始化参数而产生矛盾。

class A{ A (int i) { }};class B : virtual public A{ B (int n) : A(n) { }};class C: virtual public A{ C(int n) : A(n) { }};class D: public B, public C{ D(int n): A(n), B(n), C(n) { }};

C++ 5- 49

5.6 多重继承#include <iostream>#include <string>Using namespace std;class person{public: person (string nam, char s, int a) { name = nam; sex = s; age = a; }protected: string name; char sex; int age;};

class teacher : virtual public 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 sco;};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<<“wages:”<<wage<<endl; }private: float wage;};void main( ){ graduate

s1(“wan”,”m”,24,”assistant”,90.5,2000.50);

s1.show( );}

C++ 5- 50

5.7 基类与派生类的转换不同类型数据之间在一定条件下可以进行类型转换，

如，整数赋给双精度数，但不能赋给指针变量。这种不同类型数据之间的自动转换和赋值，称为“赋值兼容”。

我们现在关心的是，基类和派生类之间是否也有赋值兼容的关系，能否进行类型间的转换？

回答是肯定的。基类与派生类之间有赋值兼容关系，由于派生类中包含从基类继承的成员，因此可以将派生类的值赋给基类对象，在用到基类对象的时候可以用其子类对象代替。我们分以下几种情况来讨论。

C++ 5- 51

5.7 基类与派生类的转换派生类对象可以向基类对象赋值

可以用公用派生类对象对其基类对象赋值。如A a1; // 定义基类 A 对象 a1

B b1; // 定义 A 的公用派生类 B 的对象 b1

a1 = b1; // 将派生类对象 b1 的值赋给基类 A 对象 a1

这种情况形象地说，就是“大材小用”。注意：赋值后，不能通过 a1 去访问 b1 的成员。公用派生类型（书上称为子类型）是单向的、不可逆

的。 B 是 A 的公用派生类，但 A 不是 B 的公用派生类。因为基类成员不包含派生类的成员，也就无法对派生的成员赋值。

C++ 5- 52

5.7 基类与派生类的转换派生类对象可以替代基类对象，向基类对象的引用进行赋值

或初始化例如，定义了基类 A 对象 a1 ，可以定义 a1 的引用A a1; // 定义基类对象 a1

B b1; // 定义 A 的公用派生类 B 对象 b1

A&r = a1 // 定义基类 A 对象的引用变量 r ，并用 a1 初始化

注意：此时 r 不是 b1 的别名，也不与 b1 共享同一存储单元。它只是 b1 中基类部分的别名。 r 与 b1 的基类部分共享一段存储单元。，但 r 与 b1 具有相同的起始地址。

C++ 5- 53

5.7 基类与派生类的转换如果函数的形参是基类对象或基类对象的引用，相应的实参

可以用子类对象比如，有一函数 fun ：

void fun(A &r)

{ cout<<r.num<<endl; }

其形参是类 A 的对象的引用，本来实参应该为类 A

的对象，由于公用派生类对象与基类对象赋值兼容，所以可以用类 A 的公用派生类 B 的对象 b1 作为实参：

fun(b1);

当然，在 fun 函数中只能输出派生类成员 num 的值。

C++ 5- 54

5.7 基类与派生类的转换派生类对象的地址可以赋给指向基类对象的指针。例如，定义一

个基类 student ，再定义 student 类的公用派生类 graduate ，用指向基类对象的指针输出数据。

#include <iostream.g>#include <string.h>class student{public: student (int n, string nam, float s) { num= n; name=nam; score=s; } void display( ) {cout<<“num:”<<num<<endl; cout<<“name:”<<name<<endl; cout<<“score:”<<score<<endl; }private: int num; string name; char score;};

class graduate : public student{public:

graduate (int n,string nam,float s,float p): student(n,nam,s),pay(p) { } void display( ) { student::display( ); cout<<“pay:”<<pay<<endl; }private: float pay;};

void main( ){ student s1(1001,”Li”,87.5); graduate g1(2001,”Wang”,90.0,500.0); student *pt = &s1; pt->display( ); pt = &g1; pt->display( );}

C++ 5- 55

5.8 继承与组合我们已经知道，一个类可以用基类对象作为数据成员，即子

对象。现在我们说，在一个类中，以另一个类的对象作为数据成员，叫类的组合 ( composition ) 。

例如，声明 professor 类是 teacher 类的派生类，另有一个 birthdate 类，包含 year,month,day 数据成员。可以将叫声生日信息加入到 professor 类的声明中：

class teacher{public: :private: int num; string name; char sex;};

class birthdate{public: :

private: int year, month, day;};class professor : public teacher{public: :private: : birthdate birthday;};

C++ 5- 56

5.8 继承与组合继承与组合的区别

继承：派生类与基类的关系是“是”的关系，派生类是基类，白猫是猫。

组合：指一个类包含另一个类，它们是“有”的关系。上例中，教授“有”一个生日。

如果修改了成员类的部分内容，只要成员类的公用接口（如头文件名）不变，组合类可以不修改，但需要重新编译。

C++ 5- 57

习题：本章习题请上网查阅教学网页：

http://staff.ustc.edu.cn/~leeyi