资源描述
_ -可编辑修改- Function(); 示例 2-3 代码行内的空格 2.4 对齐 【规则 2-4-1】程序的分界符和 应独占一行并且位于同一列，同时与引用它们 的语句左对齐。 【规则 2-4-2】 之内的代码块在右边数格处左对齐。 示例 2-4（a）为风格良好的对齐，示例 2-4（b）为风格不良的对齐。 void Function(int x) / program code void Function(int x) / program code if (condition) / program code if (condition) / program code else _ -可编辑修改- else / program code / program code for (initialization; condition; update) / program code for (initialization; condition; update) / program code While (condition) / program code while (condition) / program code 如果出现嵌套的， 则使用缩进对齐 ，如： 示例 2-4(a) 风格良好的对齐 示例 2-4(b) 风格不良的对齐 2.5 长行拆分 【规则 2-5-1】代码行最大长度宜控制在 70 至 80 个字符以内。代码行不要过长，否 则眼睛看不过来，也不便于打印。 【规则 2-5-2】长表达式要在低优先级操作符处拆分成新行，操作符放在新行之首 （以便突出操作符）。拆分出的新行要进行适当的缩进，使排版整齐，语句可读。 if (very_longer_variable1 = very_longer_variable12) / 类的成员函数 【规则 3-1-8】用正确的反义词组命名具有互斥意义的变量或相反动作的函数等。 例如： int minValue; int maxValue; int SetValue(); int GetValue(); 【建议 3-1-1】尽量避免名字中出现数字编号，如 Value1,Value2 等，除非逻辑上的确 需要编号。这是为了防止程序 员偷懒，不肯 为命名动脑筋而 导致产生无意义的名字（因 为用数字编号最省事）。 3.2 简单的 Windows 应用程序命名规则 作者对“匈牙利” 命名规则做了合理的简化，下述的命名规则简单易用，比较适合于 Windows 应用软件的开发。 【规则 3-2-1】类名和函数名用大写字母开头的单词组合而成。 例如： class Node; / 类名 class LeafNode; / 类名 void Draw(void); / 函数名 void SetValue(int value); / 函数名 【规则 3-2-2】变量和参数用小写字母开头的单词组合而成。 例如： BOOL flag; int drawMode; _ -可编辑修改- 【规则 3-2-3】常量全用大写的字母，用下划 线分割单词。 例如： const int MAX = 100; const int MAX_LENGTH = 100; 【规则 3-2-4】静态变量加前缀 s_（表示 static）。 例如： void Init() static int s_initValue; / 静态变量 【规则 3-2-5】如果不得已需要全局变量，则使全局变量加前缀 g_（表示 global）。 例如： int g_howManyPeople; / 全局变量 int g_howMuchMoney; / 全局变量 【规则 3-2-6】类的数据成员加前缀 m_（表示 member），这样可以避免数据成员与成 员函数的参数同名。 例如： void Object:SetValue(int width, int height) m_width = width; m_height = height; 【规则 3-2-7】为了防止某一软件库中的一些标识符和其它软件库中的冲突，可以为 各种标识符加上能反映软件性质的前缀。例如三 维图形标 准 OpenGL 的所有库函数均 以 gl 开头，所有常量（或宏定义）均以 GL 开头。 3.3 简单的 Unix 应用程序命名 规则 _ -可编辑修改- 第 4 章 表达式和基本语句 读者可能怀疑：连 if、for、while、goto、switch 这样简单的东西也要探讨编程风格，是不 是小题大做？ 我真的发觉很多程序员用隐含错误的方式写表达式和基本语句，我自己也犯过类似的 错误。 表达式和语句都属于 C+/C 的短语结构语法。它 们看似简单，但使用 时隐患比较多。本 章归纳了正确使用表达式和语句的一些规则与建议。 4.1 运算符的优先级 C+/C 语言的运算符有数十个，运算符的优先级与结合律如表 4-1 所示。注意一元运算 符 + - * 的优先级高于对应的二元运算符。 优先级 运算符 结合律 ( ) - . 从左至右 ! + - （类型） sizeof + - * / 复合表达式 过于复杂 【规则 4-2-2】不要有多用途的复合表达式。 例如： d = (a = b + c) + r ; 该表达式既求 a 值又求 d 值。 应该拆分为两个独立的语句： a = b + c; d = a + r; 【规则 4-2-3】不要把程序中的复合表达式与“真正的数学表达式”混淆。 例如： if (a Func()时，对象 a 已经消失，而 p 是指向 a 的，所以 p 就成了 “野指针”。但奇怪的是我运行这个程序时居然没有出错，这 可能与编译器有关。 7.8 有了 malloc/free 为什么还要 new/delete ？ malloc 与 free 是 C+/C 语言的标准库函数， new/delete 是 C+的运算符。它们都可用于 申请动态内存和释放内存。 对于非内部数据类型的对象而言，光用 maloc/free 无法满足动态对象的要求。对象在创 建的同时要自动执行构造函数， 对象在消亡之前要自动执 行析构函数。由于 malloc/free 是库 函数而不是运算符，不在编译 器控制权限之内，不能 够把执 行构造函数和析构函数的任务强 加于 malloc/free。 因此 C+语言需要一个能完成动态内存分配和初始化工作的运算符 new，以及一个能 完成清理与释放内存工作的运算符 delete。注意 new/delete 不是库函数。 我们先看一看 malloc/free 和 new/delete 如何实现对象的动态内存管理，见示例 7-8。 class Obj public : Obj(void) cout Destroy(); / 清除工作 free(a); / 释放内存 void UseNewDelete(void) Obj *a = new Obj; / 申请动态内存并且初始化 / delete a; / 清除并且释放内存 示例 7-8 用 malloc/free 和 new/delete 如何实现对象的动态内存管理 类 Obj 的函数 Initialize 模拟了构造函数的功能，函数 Destroy 模拟了析构函数的功能。 函数 UseMallocFree 中，由于 malloc/free 不能执行构造函数与析构函数，必须调用成员函数 Initialize 和 Destroy 来完成初始化与清除工作。函数 UseNewDelete 则简单得多。 _ -可编辑修改- 所以我们不要企图用 malloc/free 来完成动态对象的内存管理，应该用 new/delete。由于 内部数据类型的“ 对象” 没有构造与析构的过程，对它们而言 malloc/free 和 new/delete 是等价 的。 既然 new/delete 的功能完全覆盖了 malloc/free，为什么 C+不把 malloc/free 淘汰出局呢？ 这是因为 C+程序经常要调用 C 函数，而 C 程序只能用 malloc/free 管理动态内存。 如果用 free 释放 “new 创建的动态对象”，那么 该对象因无法执行析构函数而可能导致程 序出错。如果用 delete 释放“malloc 申请的动态内存”，理论上讲程序不会出错，但是该程序 的可读性很差。所以 new/delete 必须配对使用，malloc/free 也一样。 7.9 内存耗尽怎么办？ 如果在申请动态内存时找不到足够大的内存块，malloc 和 new 将返回 NULL 指针，宣 告内存申请失败。通常有三种方式 处理“ 内存耗尽”问题。 （1）判断指针是否为 NULL，如果是则马上用 return 语句终止本函数。例如： void Func(void) A *a = new A; if(a = NULL) return; （2）判断指针是否为 NULL，如果是则马上用 exit(1)终止整个程序的运行。例如： void Func(void) A *a = new A; if(a = NULL) cout f(3.14f); / Base:f(float) 3.14 pb-g(); / Derived:g(void) 示例 8-2-1 成员函数的重载和覆盖 8.2.2 令人迷惑的隐藏规则 本来仅仅区别重载与覆盖并不算困难，但是 C+的隐藏规则使问题复杂性陡然增加。这 里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下： （1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无 virtual 关键字，基 类的函数将被隐藏（注意别与重载混淆）。 （2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有 virtual 关键 字。此时，基类的函数被隐藏（注意别与覆盖混淆）。 示例程序 8-2-2（a）中： （1）函数 Derived:f(float)覆盖了 Base:f(float)。 （2）函数 Derived:g(int)隐藏了 Base:g(float)，而不是重载。 （3）函数 Derived:h(float)隐藏了 Base:h(float)，而不是覆盖。 #include class Base _ -可编辑修改- public: virtual void f(float x) cout f(3.14f); / Derived:f(float) 3.14 / Bad : behavior depends on type of the pointer pb-g(3.14f); / Base:g(float) 3.14 pd-g(3.14f); / Derived:g(int) 3 (surprise!) / Bad : behavior depends on type of the pointer pb-h(3.14f); / Base:h(float) 3.14 (surprise!) pd-h(3.14f); / Derived:h(float) 3.14 示例 8-2-2（b） 重载、覆盖和隐藏的比较 8.2.3 摆脱隐藏 隐藏规则引起了不少麻烦。示例 8-2-3 程序中，语句 pd-f(10)的本意是想调用函数 Base:f(int)，但是 Base:f(int)不幸被 Derived:f(char *)隐藏了。由于数字 10 不能被隐式地转 化为字符串，所以在编译时出 错。 class Base _ -可编辑修改- public: void f(int x); ; class Derived : public Base public: void f(char *str); ; void Test(void) Derived *pd = new Derived; pd-f(10); / error 示例 8-2-3 由于隐藏而导致错误 从示例 8-2-3 看来， 隐藏规则似乎很愚蠢。但是隐藏规则至少有两个存在的理由： 写语句 pd-f(10)的人可能真的想 调用 Derived:f(char *)函数，只是他 误将参数写 错了。有了隐藏规则，编译器就可以明确指出错误，这未必不是好事。否则，编译器会静 悄悄地将错就错，程序员将很 难发现这个错误，流下 祸根。 假如类 Derived 有多个基类（多重继承），有 时搞不清楚哪些基 类定义了函数 f。如 果没有隐藏规则，那么 pd-f(10)可能会调用一个出乎意料的基 类函数 f。尽管 隐藏规则 看起来不怎么有道理，但它的确能消灭这些意外。 示例 8-2-3 中，如果语句 pd-f(10)一定要调用函数 Base:f(int)，那么将类 Derived 修改 为如下即可。 class Derived : public Base public: void f(char *str); void f(int x) Base:f(x); ; 8.3 参数的缺省值 有一些参数的值在每次函数调用时都相同， 书写这样的语 句会使人厌烦。 C+语言采用 参数的缺省值使书写变得简洁（在编译时，缺省 值由编译器自 动插入）。 参数缺省值的使用规则： 【规则 8-3-1】参数缺省值只能出现在函数的声明中，而不能出现在定义体中。 例如： void Foo(int x=0, int y=0); / 正确，缺省值出现在函数的声明中 void Foo(int x=0, int y=0) / 错误，缺省值出现在函数的定义体中 _ -可编辑修改- 为什么会这样？我想是有两个原因：一是函数的实现（定义）本来就与参数是否有缺省值 无关，所以没有必要让缺省值 出现在函数的定义体中。二是参数的缺省值可能会改动，显然 修改函数的声明比修改函数的定义要方便。 【规则 8-3-2】如果函数有多个参数，参数只能从后向前挨个儿缺省，否 则将导致函 数调用语句怪模怪样。 正确的示例如下： void Foo(int x, int y=0, int z=0); 错误的示例如下： void Foo(int x=0, int y, int z=0); 要注意，使用参数的缺省值并没有 赋予函数新的功能， 仅仅 是使书写变得简洁一些。它 可能会提高函数的易用性，但是也可能会降低函数的可理解性。所以我们只能适当地使用参 数的缺省值，要防止使用不当 产生负面效果。示例 8-3-2 中，不合理地使用参数的缺省值将 导致重载函数 output 产生二义性。 #include void output( int x); void output( int x, float y=0.0); void output( int x) cout (j) ? (i) : (j) + 2 ; 由于运算符+比运算符:的优先级高，所以上述语句并不等价于期望的 result = ( (i) (j) ? (i) : (j) ) + 2 ; 如果把宏代码改写为 #define MAX(a, b) ( (a) (b) ? (a) : (b) ) 则可以解决由优先级引起的错误。但是即使使用修改后的宏代 码也不是万无一失的，例如 语 句 result = MAX(i+, j); 将被预处理器解释为 result = (i+) (j) ? (i+) : (j); 对于 C+ 而言，使用宏代码还有另一种缺点：无法操作类的私有数据成员。 让我们看看 C+ 的“函数内联”是如何工作的。对于任何内联函数，编译器在符号表里 放入函数的声明（包括名字、参数类型、返回 值类型）。如果编译器没有发现内联函数存在错 误，那么该函数的代码也被放入符号表里。在调用一个内联 函数时，编译器首先检查调用是 否正确（进行类型安全检查，或者 进行自动类型转换，当然对所有的函数都一样）。如果正确， 内联函数的代码就会直接替换函数调用，于是省去了函数调用的开销。 这个过程与预处理有 显著的不同，因为预处理器不能 进行类型安全检查，或者 进 行自动类型转换。假如内联函数 是成员函数，对象的地址（this）会被放在合适的地方，这也是预处理器办不到的。 C+ 语言的函数内 联机制既具 备宏代码的效率，又增加了安全性，而且可以自由操作 类的数据成员。所以在 C+ 程序中，应该用内联函数取代所有宏代码， “断言 assert”恐怕是唯 一的例外。assert 是仅在 Debug 版本起作用的宏，它用于 检查 “不应该” 发生的情况。 为了不 在程序的 Debug 版本和 Release 版本引起差别， assert 不应该产生任何副作用。如果 assert 是 函数，由于函数调用会引起内存、代码的变动，那么将导致 Debug 版本与 Release 版本存在 差异。所以 assert 不是函数，而是宏。 （参见 6.5 节“使用断言 ”） 8.5.2 内联函数的编程风格 关键字 inline 必须与函数定义体放在一起才能使函数成为内联， 仅将 inline 放在函数声 明前面不起任何作用。如下风 格的函数 Foo 不能成为内联函数： inline void Foo(int x, int y); / inline 仅与函数声明放在一起 void Foo(int x, int y) _ -可编辑修改- 而如下风格的函数 Foo 则成为内联函数： void Foo(int x, int y); inline void Foo(int x, int y) / inline 与函数定义体放在一起 所以说，inline 是一种“用于实现的关键字”，而不是一种“用于声明的关键字” 。一般地， 用户可以阅读函数的声明，但是看不到函数的定义。尽管在大多数教科书中内联函数的声明、 定义体前面都加了 inline 关键字，但我 认为 inline 不应该出现在函数的声明中。这个细节虽 然不会影响函数的功能，但是体现了高质量 C+/C 程序设计风格的一个基本原则：声明与定 义不可混为一谈，用户没有必要、也不应该知道函数是否需要内 联。 定义在类声明之中的成员函数将自动地成为内联函数，例如 class A public: void Foo(int x, int y) / 自动地成为内联函数 将成员函数的定义体放在类声明之中虽然能带来书写上的方便，但不是一种良好的 编程风 格，上例应该改成： / 头文件 class A public: void Foo(int x, int y)； / 定义文件 inline void A:Foo(int x, int y) 8.5.3 慎用内联 内联能提高函数的执行效率， 为什么不把所有的函数都定 义成内联函数？ 如果所有的函数都是内联函数， 还用得着“ 内联”这个关键字吗？ 内联是以代码膨胀（复制）为代价， 仅仅省去了函数调 用的开销，从而提高函数的 执行效 率。如果执行函数体内代码的 时间，相比于函数 调用的开销较 大，那么效率的收获会很少。 另一方面，每一处内联函数的 调用都要复制代码，将使程序的总代码量增大，消耗更多的内 存空间。以下情况不宜使用内 联： （1）如果函数体内的代码比较长，使用内 联将导致内存消耗代价 较高。 （2）如果函数体内出现循环，那么 执行函数体内代码的时间 要比函数调用的开销大。 类的构造函数和析构函数容易让人误解成使用内联更有效。要当心构造函数和析构函 _ -可编辑修改- 数可能会隐藏一些行为，如“ 偷偷地”执行了基类或成员对象的构造函数和析构函数。所以不 要随便地将构造函数和析构函数的定义体放在类声明中。 一个好的编译器将会根据函数的定义体，自 动地取消不值 得的内联（这进一步说明了 inline 不 应该出 现在函数的声明中）。 8.6 一些心得体会 C+ 语言中的重载、内 联、缺省参数、隐式转换等机制展现了很多优点，但是这些优点 的背后都隐藏着一些隐患。正如人 们的饮食，少食和暴食都不可取，应当恰到好处。我们要 辨证地看待 C+的新机制，应该恰如其分地使用它们。 虽然这会使我们编程时多费一些心思， 少了一些痛快，但这才是编程的 艺术。 _ -可编辑修改- 第 9 章 类的构造函数、析构函数与赋值函数 构造函数、析构函数与赋值函数是每个 类最基本的函数。它们太普通以致让人容易麻痹 大意，其实这些貌似简单的函数就象没有 顶盖的下水道那 样危险。 每个类只有一个析构函数和一个赋值函数，但可以有多个构造函数（包含一个拷 贝构造 函数，其它的称为普通构造函数）。对于任意一个类 A，如果不想编写上述函数，C+ 编译器 将自动为 A 产生四个缺省的函数，如 A(void); / 缺省的无参数构造函数 A(const A / 缺省的拷贝构造函数 A(void); / 缺省的析构函数 A / 缺省的赋值函数 这不禁让人疑惑，既然能自动 生成函数， 为什么还要程序员编 写？ 原因如下： （1）如果使用“缺省的无参数构造函数”和“ 缺省的析构函数 ”，等于放弃了自主“初始化”和“ 清 除”的机会，C+ 发明人 Stroustrup 的好心好意白费了。 （2）“缺省的拷贝构造函数” 和“ 缺省的赋值函数”均采用“位拷贝”而非“值拷贝”的方式来实现， 倘若类中含有指针变量，这两个函数注定将出 错。 对于那些没有吃够苦头的 C+程序员，如果他说编写构造函数、析构函数与赋值函数很 容易，可以不用动脑筋，表明他的认识还比较肤浅，水平有待于提高。 本章以类 String 的设计与实现为 例，深入 阐述被很多教科 书忽视了的道理。String 的结 构如下： class String public: String(const char *str = NULL); / 普通构造函数 String(const String / 拷贝构造函数 String(void); / 析构函数 String / 赋值 函数 private: char *m_data; / 用于保存字符串 ; 9.1 构造函数与析构函数的起源 作为比 C 更先进的语言，C+提供了更好的机制来增强程序的安全性。C+编译器具有 严格的类型安全检查功能，它几乎能找出程序中所有的语 法问题， 这的确帮了程序员的大忙。 但是程序通过了编译检查并不表示错误已经不存在了，在“错误”的大家庭里， “语法错误”的 地位只能算是小弟弟。级别高的 错误通常隐藏得很深，就象狡猾的罪犯，想逮住他可不容易。 根据经验，不少难以察觉 的程序错误是由于变量没有被正确初始化或清除造成的，而初 _ -可编辑修改- 始化和清除工作很容易被人遗忘。 Stroustrup 在设计 C+语言时充分考虑了这个问题并很好 地予以解决：把对象的初始化工作放在构造函数中，把清除工作放在析构函数中。当对象被 创建时，构造函数被自动执行。当对象消亡时，析构函数被自动执行。这下就不用担心忘了 对象的初始化和清除工作。 构造函数与析构函数的名字不能随便起，必须让编译 器认得出才可以被自动执行。 Stroustrup 的命名方法既简单 又合理：让构造函数、析构函数与类同名，由于析构函数的目的 与构造函数的相反，就加前缀 以示区别。 除了名字外，构造函数与析构函数的另一个特别之处是没有返回 值类型， 这与返回值类 型为 void 的函数不同。构造函数与析构函数的使命非常明确，就象出生与死亡，光溜溜地来 光溜溜地去。如果它们有返回 值类型，那么 编译器将不知所措。为了防止节外生枝，干脆规 定没有返回值类型。 （以上典故参考了文献 Eekel, p55-p56） 9.2 构造函数的初始化表 构造函数有个特殊的初始化方式叫“初始化表达式表”（简称初始化表）。初始化表位于函 数参数表之后，却在函数体 之前。 这说明该表里的初始化工作发生在函数体内的任何代 码被执行之前。 构造函数初始化表的使用规则： 如果类存在继承关系，派生 类必须在其初始化表里 调用基类的构造函数。 例如 class A A(int x); / A 的构造函数 ; class B : public A B(int x, int y);/ B 的构造函数 ; B:B(int x, int y) : A(x) / 在初始化表里调用 A 的构造函数 类 的 const 常量只能在初始化表里被初始化，因 为它不能在函数体内用赋值的方 式来初始化（参见 5.4 节）。 类的数据成 员的初始化可以采用初始化表或函数体内赋值两种方式，这两种方式 的效率不完全相同。 非内部数据类型的成员对象应当采用第一种方式初始化，以 获取更高的效率。 例如 class A A(void); / 无参数构造函数 A(const A / 拷贝构造函数 A / 赋值函数 ； _ -可编辑修改- class B public: B(const A / B 的构造函数 private: A m_a; / 成员对象 ; 示例 9-2(a)中，类 B 的构造函数在其初始化表里调用了类 A 的拷贝构造函数，从而将成 员对象 m_a 初始化。 示例 9-2 (b)中，类 B 的构造函数在函数体内用赋值的方式将成员对象 m_a 初始化。我 们看到的只是一条赋值语句，但 实际上 B 的构造函数干了两件事：先暗地里创建 m_a 对象 （调用了 A 的无参数构造函数），再调用类 A 的赋值函数，将参数 a 赋给 m_a。 B:B(const A 示例 9-2(a) 成员对象在初始化表中被初始化 示例 9-2(b) 成员对象在函数体内被初始化 对于内部数据类型的数据成员而言，两种初始化方式的效率几乎没有区 别，但后者的程 序版式似乎更清晰些。若类 F 的声明如下： class F public: F(int x, int y); / 构造函数 private: int m_x, m_y; int m_i, m_j; 示例 9-2(c)中 F 的构造函数采用了第一种初始化方式，示例 9-2(d)中 F 的构造函数采用 了第二种初始化方式。 F:F(int x, int y) : m_x(x), m_y(y) m_i = 0; m_j = 0; F:F(int x, int y) m_x = x; m_y = y; m_i = 0; m_j = 0; 示例 9-2(c) 数据成员在初始化表中被初始化 示例 9-2(d) 数据成员在函数体内被初始化 _ -可编辑修改- 9.3 构造和析构的次序 构造从类层次的最根处开始，在每一 层中，首先 调用基 类的构造函数，然后调用成员对 象的构造函数。析构则严格按照与构造相反的次序 执行， 该 次序是唯一的，否则编译器将无 法自动执行析构过程。 一个有趣的现象是，成员对象初始化的次序完全不受它 们 在初始化表中次序的影响，只 由成员对象在类中声明的次序决定。 这是因为类的声明是唯一的，而类的构造函数可以有多 个，因此会有多个不同次序的初始化表。如果成员对象按照初始化表的次序进行构造，这将 导致析构函数无法得到唯一的逆序。Eckel, p260-261 9.4 示例：类 String 的构造函数与析构函数 / String 的普通构造函数 String:String(const char *str) if(str=NULL) m_data = new char1; *m_data = 0; else int length = strlen(str); m_data = new charlength+1; strcpy(m_data, str); / String 的析构函数 String:String(void) delete m_data; / 由于 m_data 是内部数据类型，也可以写成 delete m_data; 9.5 不要轻视拷贝构造函数与赋值函数 由于并非所有的对象都会使用拷贝构造函数和赋值函数，程序员可能对这两个函数有 些轻视。请先记住以下的警告，在阅读正文时就会多心： 本章开头讲过，如果不主 动编写拷贝构造函数和 赋值函数， 编译器将以“位拷贝” 的 方式自动生成缺省的函数。倘若 类中含有指针变量，那么 这 两个缺省的函数就隐含了错 误。以类 String 的两个对象 a,b 为例，假 设 a.m_data 的内容 为“hello”，b.m_data 的内容 _ -可编辑修改- 为“world”。 现将 a 赋给 b，缺省 赋值函数的“位拷贝”意味着执行 b.m_data = a.m_data。这将造 成三个错误：一是 b.m_data 原有的内存没被释放，造成内存泄露；二是 b.m_data 和 a.m_data 指向同一块内存，a 或 b 任何一方变动都会影响另一方；三是在对象被析构时， m_data 被释放了两次。 拷贝构造函数和赋值函数非常容易混淆，常导致错写、错用。拷贝构造函数是在对 象被创建时调用的，而赋值函数只能被已 经存在了的对象 调用。以下程序中，第三个语 句和第四个语句很相似，你分得清楚哪个 调用了拷贝构造函数，哪个调用了赋值函数吗？ String a(“hello”); String b(“world”); String c = a; / 调用了拷贝构造函数，最好写成 c(a); c = b; / 调用了赋值函数 本例中第三个语句的风格较差，宜改写成 String c(a) 以区别于第四个语句。 9.6 示例：类 String 的拷贝构造函数与赋值函数 / 拷贝构造函数 String:String(const String m_data = new charlength+1; strcpy(m_data, other.m_data); / 赋值函数 String / (2) 释放原有的内存资源 delete m_data; / （3）分配新的内存资源，并复制内容 int length = strlen(other.m_data); m_data = new charlength+1; strcpy(m_data, other.m_data); / （4）返回本对象的引用 return *this; _ -可编辑修改- 类 String 拷 贝构造函数与普通构造函数（参 见 9.4 节）的区 别是：在函数入口处无需与 NULL 进行比较， 这是因为“ 引用” 不可能是 NULL，而 “指针”可以为 NULL。 类 String 的 赋值函数比构造函数复 杂得多，分四步 实现 ： （1）第一步，检查自赋值。你可能会认为多此一举，难道有人会愚蠢到写出 a = a 这样的自赋 值语句！的确不会。但是间接的自 赋值仍有可能出现，例如 / 内容自赋值 b = a; c = b; a = c; / 地址自赋值 b = a = *b; 也许有人会说：“即使出现自赋值，我也可以不理睬，大不了化点时间让对象复制自己而 已，反正不会出错！” 他真的说错了。看看第二步的 delete，自杀后还能复制自己吗？所以，如果发现自赋值， 应该马上终止函数。注意不要将 检查自赋值的 if 语句 if(this = / 私有的拷贝构造函数 A / 私有的赋值函数 ; _ -可编辑修改- 如果有人试图编写如下程序： A b(a); / 调用了私有的拷贝构造函数 b = a; / 调用了私有的赋值函数 编译器将指出错误，因为外界不可以操作 A 的私有函数。 9.8 如何在派生类中实现类的基本函数 基类的构造函数、析构函数、赋值函数都不能被派生类继承。如果类之间存在继承关系， 在编写上述基本函数时应注意以下事项： 派生类的构造函数应在其初始化表里调用基类的构造函数。 基类与派生类的析构函数应该为虚（即加 virtual 关键字）。例如 #include class Base public: virtual Base() cout “Base“ endl ; ; class Derived : public Base public: virtual Derived() cout “Derived“ endl ; ; void main(void) Base * pB = new Derived; / upcast delete pB; 输出结果为： Derived Base 如果析构函数不为虚，那么输 出结果为 Base 在编写派生类的赋值函数时，注意不要忘 记对基 类的数据成员重新赋值。例如： class Base public: Base / 类 Base 的赋值 函数 private: _ -可编辑修改- int m_i, m_j, m_k; ; class Derived : public Base public: Derived / 类 Derived 的赋值函数 private: int m_x, m_y, m_z; ; Derived /（2）对基类的数据成员重新赋值 Base:operate =(other); / 因为不能直接操作私有数据成 员 /（3）对派生类的数据成员赋值 m_x = other.m_x; m_y = other.m_y; m_z = other.m_z; /（4）返回本对象的引用 return *this; 9.9 一些心得体会 有些 C+程序设计书籍称构造函数、析构函数和赋值函数是类的“Big-Three”，它们的确 是任何类最重要的函数，不容 轻视。 也许你认为本章的内容已经够多了，学会了就能平安无事，我不能作这个保证。如果你 希望吃透“Big-Three”，请好好阅读参考文献Cline Meyers Murry。 _ -可编辑修改- 第 10 章 类的继承与组合 对象（Object）是类（Class）的一个实例（Instance）。如果将对象比作房子，那么类就是房子 的设计图纸。所以面向对象设计 的重点是类的设计，而不是对象的设计。 对于 C+程序而言，设计孤立的类是比较容易的，难的是正确设计基类及其派生类。本 章仅仅论述“继 承” （Inheritance）和“组合” （Composition）的概念。 注意，当前面向对象技术的应 用热点是 COM 和 CORBA，这些内容超出了 C+教材的 范畴，请阅读 COM 和 CORBA 相关论著。 10.1 继承 如果 A 是基类，B 是 A 的派生类，那么 B 将继承 A 的数据和函数。例如： class A public: 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); 其中 str
展开阅读全文