原创 C++ 学习之路（八） 类之间的继承

类之间的继承

    类的一个重要特征是继承，这使得我们可以基于一个类生成另一个类的对象，以便使后

者拥有前者的某些成员，再加上它自己的一些成员。例如，假设我们要声明一系列类型

的多边形，比如长方形 CRectangle 或三角形 CTriangle。它们有一些共同的特征，比如

都可以只用两条边来描述：高（height）和底（base）。

这个特点可以用一个类 CPolygon 来表示，基于这个类我们可以引申出上面提到的两个

类 CRectangle 和 CTriangle 。

类 CPolygon 包含所有多边形共有的成员。在我们的例子里就是： width 和 height。

而 CRectangle 和 CTriangle 将为它的子类(derived classes)。

由其它类引申而来的子类继承基类的所有可视成员，意思是说，如果一个基类包含成员

A ，而我们将它引申为另一个包含成员 B 的类，则这个子类将同时包含 A 和 B。

     要定义一个类的子类，我们必须在子类的声明中使用冒号(colon)操作符: ，如下所示：

class derived_class_name: public base_class_name;

这里 derived_class_name 为子类(derived class)名称，base_class_name 为基类(base

class)名称。public 也可以根据需要换为 protected 或 private，描述了被继承的成

员的访问权限，// derived classes

#include

Class CPolygon  //定义一个多边形的基类

{

protected:

int width, height;

public:

void set_values (int a, int b)

{ width=a; height=b;}

};

class CRectangle: public CPolygon

{

public:

int area (void)

{

return (width *height); }

};

};

class CTriangle: public CPolygon {

public:

int area (void){ return (width *

height / 2); }

};

int main () {

CRectangle rect;

CTriangle trgl;

rect.set_values (4,5);

trgl.set_values (4,5);

cout << rect.area() << endl;

cout << trgl.area() << endl;

return 0;

}

输出结果：

20

10

标识符 protected 与 private 类似，它们的唯一区别在继承时才表现出来。当定义一个

子类的时候，基类的 protected 成员可以被子类的其它成员所使用，然而 private 成员就不

可以。因为我们希望 CPolygon 的成员 width 和 height 能够被子类 CRectangle 和

CTriangle 的成员所访问，而不只是被CPolygon自身的成员操作，我们使用了protected

访问权限，而不是 private。

下表按照谁能访问总结了不同访问权限类型：

可以访问

这里"非成员"指从 class 以外的任何地方引用，例如从 main()中，从其它的 class 中或从全域(global)或本地(local)的任何函数中。

在我们的例子中，CRectangle 和 CTriangle 继承的成员与基类 CPolygon 拥有同样的访

问限制：

CPolygon::width          // protected access

CRectangle::width         // protected access

CPolygon::set_values()     // public access

CRectangle::set_values()   // public access

这是因为我们在继承的时候使用的是 public，记得我们用的是：class CRectangle: public CPolygon;

这里关键字 public 表示新的类(CRectangle)从基类(CPolygon)所继承的成员必须获得

最低程度保护。即从基本类中继承的成员将会是public的权限。这种被继承成员的访问限制的最低程度可以通过使用 protected 或

private 而不是 public 来改变。

最常用的继承限制除了 public 外就是 private ，它被用来将基类完全封装起来，因为

在这种情况下，除了子类自身外，其它任何程序都不能访问那些从基类继承而来的成员。

不过大多数情况下继承都是使用 public 的。

如果没有明确写出访问限制，所有由关键字 class 生成的类被默认为 private ，而所有

由关键字 struct 生成的类被默认为 public。

基类中继承

理论上说，子类(drived class)继承了基类(base class)的所有成员，除了：

•构造函数 Constructor 和析构函数 destructor

•operator=() 成员

•friends

虽然基类的构造函数和析构函数没有被继承，但是当一个子类的 object 被生成或销毁的

时候，其基类的默认构造函数 (即，没有任何参数的构造函数)和析构函数总是被自动调

用的。

如果基类没有默认构造函数，或你希望当子类生成新的 object 时，基类的某个重载的构

造函数被调用，你需要在子类的每一个构造函数的定义中指定它：

derived_class_name (parameters) : base_class_name (parameters) {}

例如 ：

// constructors and derivated classes

#include <iostream.h>

class mother

{

public:

mother ()

{

cout << "mother: noparameters\n";

}

mother (int a)

{

cout << "mother: intparameter\n"

}

};

class daughter : public mother

{

public:

daughter (int a)    //这里没写,将调用默认的构造函数

{

cout << "daughter: intparameter\n\n";

}

};

class son : public mother 

{

public:

son (int a) : mother (a)   //在这里指定了构造函数

{

cout << "son: intparameter\n\n"; }

};

int main ()

 {

daughter cynthia (1);

son daniel(1);

return 0;

}

mother: no parameters

daughter: int parameter

mother: int parameter

son: int parameter

观察当一个新的 daughter object 生成的时候 mother 的哪一个构造函数被调用了，而当

新的 son object 生成的时候，又是哪一个被调用了。不同的构造函数被调用是因为

daughter 和 son 的构造函数的定义不同：

daughter (int a)

// 没有特别制定：调用默认 constructor

son (int a) : mother (a)

// 指定了 constructor: 调用被指定的构造函数

多重继承(Multiple inheritance)

在 C++ 中，一个 class 可以从多个 class 中继承属性或函数，只需要在子类的声明中用

逗号将不同基类分开就可以了。例如，如果我们有一个特殊的 class COutput 可以实现

向屏幕打印的功能，我们同时希望我们的类 CRectangle 和 CTriangle 在 CPolygon 之

外还继承一些其它的成员，我们可以这样写：

class CRectangle: public CPolygon, public COutput {

class CTriangle: public CPolygon, public COutput {

以下是一个完整的例子：

// multiple inheritance

#include <iostream.h>

class CPolygon

 {

protected:

int width, height;

public:

void set_values (int a, int b)

{ width=a; height=b;}

};

class COutput

 {

public:

void output (int i);

};

void COutput::output (int i) {

cout << i << endl;

}

class CRectangle: public CPolygon, public

COutput {

public:

int area (void)

{ return (width * height); }

};

class CTriangle: public CPolygon, public

COutput

{

public:

int area (void)

{ return (width * height / 2); }

};

int main () {

CRectangle rect;

CTriangle trgl;

rect.set_values (4,5);

trgl.set_values (4,5);

rect.output (rect.area());

trgl.output (trgl.area());

return 0;

}

结果是：

20

10