按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！
void Func1（void）；
void Func2（void）；
｝；
class B ： public A
｛
public：
void Func3（void）；
void Func4（void）；
｝；
main（）
｛
B b；
b。Func1（）； // B从A继承了函数Func1
b。Func2（）； // B从A继承了函数Func2
b。Func3（）；
b。Func4（）；
｝
这个简单的示例程序说明了一个事实：C＋＋的〃继承〃特性可以提高程序的可复用性。正因为〃继承〃太有用、太容易用，才要防止乱用〃继承〃。我们应当给〃继承〃立一些使用规则。
* 【规则10…1…1】如果类A和类B毫不相关，不可以为了使B的功能更多些而让B继承A的功能和属性。不要觉得〃白吃白不吃〃，让一个好端端的健壮青年无缘无故地吃人参补身体。
* 【规则10…1…2】若在逻辑上B是A的〃一种〃（a kind of ），则允许B继承A的功能和属性。例如男人（Man）是人（Human）的一种，男孩（Boy）是男人的一种。那么类Man可以从类Human派生，类Boy可以从类Man派生。
class Human
｛
。。。
｝；
class Man ： public Human
｛
。。。
｝；
class Boy ： public Man
｛
。。。
｝；
* 注意事项
【规则10…1…2】看起来很简单，但是实际应用时可能会有意外，继承的概念在程序世界与现实世界并不完全相同。
例如从生物学角度讲，鸵鸟（Ostrich）是鸟（Bird）的一种，按理说类Ostrich应该可以从类Bird派生。但是鸵鸟不能飞，那么Ostrich：：Fly是什么东西？
class Bird
｛
public：
virtual void Fly（void）；
。。。
｝；
class Ostrich ： public Bird
｛
。。。
｝；
例如从数学角度讲，圆（Circle）是一种特殊的椭圆（Ellipse），按理说类Circle应该可以从类Ellipse派生。但是椭圆有长轴和短轴，如果圆继承了椭圆的长轴和短轴，岂非画蛇添足？
所以更加严格的继承规则应当是：若在逻辑上B是A的〃一种〃，并且A的所有功能和属性对B而言都有意义，则允许B继承A的功能和属性。
10。2 组合
* 【规则10…2…1】若在逻辑上A是B的〃一部分〃（a part of），则不允许B从A派生，而是要用A和其它东西组合出B。
例如眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head应该由类Eye、Nose、Mouth、Ear组合而成，不是派生而成。如示例10…2…1所示。
class Eye
｛
public：
void Look（void）；
｝；
class Nose
｛
public：
void Smell（void）；
｝；
class Mouth
｛
public：
void Eat（void）；
｝；
class Ear
｛
public：
void Listen（void）；
｝；
// 正确的设计，虽然代码冗长。
class Head
｛
public：
void Look（void） ｛ m_eye。Look（）； ｝
void Smell（void） ｛ m_nose。Smell（）； ｝
void Eat（void） ｛ m_mouth。Eat（）； ｝
void Listen（void） ｛ m_ear。Listen（）； ｝
private：
Eye m_eye；
Nose m_nose；
Mouth m_mouth；
Ear m_ear；
｝；
示例10…2…1 Head由Eye、Nose、Mouth、Ear组合而成
如果允许Head从Eye、Nose、Mouth、Ear派生而成，那么Head将自动具有Look、 Smell、Eat、Listen这些功能。示例10…2…2十分简短并且运行正确，但是这种设计方法却是不对的。
// 功能正确并且代码简洁，但是设计方法不对。
class Head ： public Eye； public Nose； public Mouth； public Ear
｛
｝；
示例10…2…2 Head从Eye、Nose、Mouth、Ear派生而成
一只公鸡使劲地追打一只刚下了蛋的母鸡，你知道为什么吗？
因为母鸡下了鸭蛋。
很多程序员经不起〃继承〃的诱惑而犯下设计错误。〃运行正确〃的程序不见得是高质量的程序，此处就是一个例证。
第11章 其它编程经验
11。1 使用const提高函数的健壮性
看到const关键字，C＋＋程序员首先想到的可能是const常量。这可不是良好的条件反射。如果只知道用const定义常量，那么相当于把火药仅用于制作鞭炮。const更大的魅力是它可以修饰函数的参数、返回值，甚至函数的定义体。
const是constant的缩写，〃恒定不变〃的意思。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。所以很多C＋＋程序设计书籍建议：〃Use const whenever you need〃。
11。1。1 用const修饰函数的参数
如果参数作输出用，不论它是什么数据类型，也不论它采用〃指针传递〃还是〃引用传递〃，都不能加const修饰，否则该参数将失去输出功能。
const只能修饰输入参数：
* 如果输入参数采用〃指针传递〃，那么加const修饰可以防止意外地改动该指针，起到保护作用。
例如StringCopy函数：
void StringCopy（char *strDestination； const char *strSource）；
其中strSource是输入参数，strDestination是输出参数。给strSource加上const修饰后，如果函数体内的语句试图改动strSource的内容，编译器将指出错误。
* 如果输入参数采用〃值传递〃，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const修饰。
例如不要将函数void Func1（int x） 写成void Func1（const int x）。同理不要将函数void Func2（A a） 写成void Func2（const A a）。其中A为用户自定义的数据类型。
* 对于非内部数据类型的参数而言，象void Func（A a） 这样声明的函数注定效率比较底。因为函数体内将产生A类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。
为了提高效率，可以将函数声明改为void Func（A &a），因为〃引用传递〃仅借用一下参数的别名而已，不需要产生临时对象。但是函数void Func（A &a） 存在一个缺点：〃引用传递〃有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为void Func（const A &a）。
以此类推，是否应将void Func（int x） 改写为void Func（const int &x），以便提高效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制也非常快，〃值传递〃和〃引用传递〃的效率几乎相当。
问题是如此的缠绵，我只好将〃const &〃修饰输入参数的用法总结一下，如表11…1…1所示。
对于非内部数据类型的输入参数，应该将〃值传递〃的方式改为〃const引用传递〃，目的是提高效率。例如将void Func（A a） 改为void Func（const A &a）。
对于内部数据类型的输入参数，不要将〃值传递〃的方式改为〃const引用传递〃。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func（int x） 不应该改为void Func（const int &x）。
表11…1…1 〃const &〃修饰输入参数的规则
11。1。2 用const修饰函数的返回值
* 如果给以〃指针传递〃方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const修饰的同类型指针。
例如函数
const char * GetString（void）；
如下语句将出现编译错误：
char *str = GetString（）；
正确的用法是
const char *str = GetString（）；
* 如果函数返回值采用〃值传递方式〃，由于函数会把返回值复制到外部临时的存储单元中，加const修饰没有任何价值。
例如不要把函数int GetInt（void） 写成const int GetInt（void）。
同理不要把函数A GetA（void） 写成const A GetA（void），其中A为用户自定义的数据类型。
如果返回值不是内部数据类型，将函数A GetA（void） 改写为const A & GetA（void）的确能提高效率。但此时千万千万要小心，一定要搞清楚函数究竟是想返回一个对象的〃拷贝〃还是仅返回〃别名〃就可以了，否则程序会出错。见6。2节〃返回值的规则〃。
* 函数返回值采用〃引用传递〃的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达。
例如
class A
｛。。。
A & operate = （const A &other）； // 赋值函数
｝；
A a； b； c； // a； b； c 为A的对象
。。。
a = b = c； // 正常的链式赋值
（a = b） = c； // 不正常的链式赋值，但合法
如果将赋值函数的返回值加const修饰，那么该返回值的内容不允许被改动。上例中，语句 a = b = c仍然正确，但是语句 （a = b） = c 则是非法的。
11。1。3 const成员函数
任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其它非const成员函数，编译器将指出错误，这无疑会提高程序的健壮性。
以下程序中，类stack的成员函数GetCount仅用于计数，从逻辑上讲GetCount应当为const函数。编译器将指出GetCount函数中的错误。
class Stack
｛
public：
void Push（int elem）；
int Pop（void）；
int GetCount（void） const； // const成员函数
private：
int m_num；
int m_data＇100＇；
｝；
int Stack：：GetCount（void） const
｛
＋＋ m_num； // 编译错误，企图修改数据成员m_num
Pop（）； // 编译错误，企图调用非const函数
return m_num；
｝
c