高质量C\C++编程

发布时间:2016-12-11 14:10:25 编辑:www.fx114.net 分享查询网我要评论
本篇文章主要介绍了"高质量C\C++编程",主要涉及到高质量C\C++编程方面的内容,对于高质量C\C++编程感兴趣的同学可以参考一下。

平时的编程中有养成了很多不良的习惯,往往我们都不在意,但总是这些不在意导致我们要浪费很多时间在Debug上,看了本书《高质量C编程指南》,书的地址http://download.csdn.net/detail/zhangyang1990828/5242261 高质量C\C++编程(一) (第一部分是一些简单的帮助改正习惯和养成良好习惯的,都是细节,但往往细节决定成败;第二部分会讲述一些更深层的专题) 以下是我看后的整理: 1  关于高质量的关键词:正确性、健壮性、可靠性、效率、易用性、可读性(可理解性)、可扩展性、可复 用性、兼容性、可移植性等 2  版权和版本的声明位于头文件和定义文件的开头,主要内容有: (1)版权信息。 (2)文件名称,标识符,摘要。 (3)当前版本号,作者/修改者,完成日期。 (4)版本历史信息。 /* * Copyright (c) 2001,上海贝尔有限公司网络应用事业部 * All rights reserved. * * 文件名称:filename.h * 文件标识:见配置管理计划书 * 摘要:简要描述本文件的内容 * * 当前版本:1.1 * 作者:输入作者(或修改者)名字 * 完成日期:2001年7月20日 * * 取代版本:1.0 * 原作者:输入原作者(或修改者)名字 * 完成日期:2001年5月10日 */ 3  为了防止头文件被重复引用,应当用ifndef/define/endif 结构产生预处 理块。 4  用 #include <filename.h> 格式来引用标准库的头文件(编译器将从标 准库目录开始搜索)。 5  用 #include “filename.h” 格式来引用非标准库的头文件(编译器将从 用户的工作目录开始搜索)。 6  头文件中只存放“声明”而不存放“定义” // 版权和版本声明,此处省略。 #ifndef GRAPHICS_H // 防止graphics.h 被重复引用 #define GRAPHICS_H #include <math.h> // 引用标准库的头文件 … #include “myheader.h” // 引用非标准库的头文件 … void Function1(…); // 全局函数声明 … class Box // 类结构声明 { … }; #endif 7  定义文件:    (1) 定义文件开头处的版权和版本声明。    (2) 对一些头文件的引用。    (3) 程序的实现体(包括数据和代码)。 假设定义文件的名称为 graphics.cpp,定义文件的结构。 // 版权和版本声明,此处省略。 #include “graphics.h” // 引用头文件 … // 全局函数的实现体 void Function1(…) { … } // 类成员函数的实现体 void Box::Draw(…) { … } 8  头文件作用:     (1)通过头文件来调用库功能。在很多场合,源代码不便(或不准)向用户公布,只要 向用户提供头文件和二进制的库即可。用户只需要按照头文件中的接口声明来调用库功 能,而不必关心接口怎么实现的。编译器会从库中提取相应的代码。     (2)头文件能加强类型安全检查。如果某个接口被实现或被使用时,其方式与头文件中 的声明不一致,编译器就会指出错误,这一简单的规则能大大减轻程序员调试、改错的 负担。 9  如果一个软件的头文件数目比较多(如超过十个),通常应将头文件和定义文件分别 保存于不同的目录,以便于维护。 例如可将头文件保存于include 目录,将定义文件保存于source 目录(可以是多级 目录)。 如果某些头文件是私有的,它不会被用户的程序直接引用,则没有必要公开其“声 明”。为了加强信息隐藏,这些私有的头文件可以和定义文件存放于同一个目录。 10  在每个类声明之后、每个函数定义结束之后都要加空行。 11  在一个函数体内,逻揖上密切相关的语句之间不加空行,其它地方应 加空行分隔。 12  一行代码只做一件事情,如只定义一个变量,或只写一条语句。这样 的代码容易阅读,并且方便于写注释。 13  if、for、while、do 等语句自占一行,执行语句不得紧跟其后。不论 执行语句有多少都要加{}。这样可以防止书写失误。 14  尽可能在定义变量的同时初始化该变量(就近原则) 如果变量的引用处和其定义处相隔比较远,变量的初始化很容易被忘记。如果引用 了未被初始化的变量,可能会导致程序错误。类中一定要记着构造函数中初始化。 15  关键字之后要留空格。象const、virtual、inline、case 等关键字之后 至少要留一个空格,否则无法辨析关键字。象if、for、while 等关键字之后应留一个 空格再跟左括号‘(’,以突出关键字。 16  函数名之后不要留空格,紧跟左括号‘(’,以与关键字区别。 ‘(’向后紧跟,‘)’、‘,’、‘;’向前紧跟,紧跟处不留空格。 17  ‘,’之后要留空格,如Function(x, y, z)。如果‘;’不是一行的结束符号,其后要留空格,如for (initialization;                      condition; update)。 18  赋值操作符、比较操作符、算术操作符、逻辑操作符、位域操作符, 如“=”、“+=” “>=”、“<=”、“+”、“*”、“%”、“&&”、“||”、“<<”,“^”等二元 操作符的前后应当加空格。 19  一元操作符如“!”、“~”、“++”、“--”、“&”(地址运算符)等前后不 加空格。 20  象“[]”、“.”、“->”这类操作符前后不加空格。 21  对于表达式比较长的for 语句和if 语句,为了紧凑起见可以适当地去 掉一些空格,如for (i=0; i<10; i++)和if ((a<=b) && (c<=d)) void Func1(int x, int y, int z); // 良好的风格 void Func1 (int x,int y,int z); // 不良的风格 if (year >= 2000) // 良好的风格 if(year>=2000) // 不良的风格 if ((a>=b) && (c<=d)) // 良好的风格 if(a>=b&&c<=d) // 不良的风格 for (i=0; i<10; i++) // 良好的风格 for(i=0;i<10;i++) // 不良的风格 for (i = 0; I < 10; i ++) // 过多的空格 x = a < b ? a : b; // 良好的风格 x=a<b?a:b; // 不好的风格 int *x = &y; // 良好的风格 int * x = & y; // 不良的风格 array[5] = 0; // 不要写成 array [ 5 ] = 0; a.Function(); // 不要写成 a . Function(); b->Function(); // 不要写成 b -> Function(); 21  程序的分界符‘{’和‘}’应独占一行并且位于同一列,同时与引用 它们的语句左对齐。 22  { }之内的代码块在‘{’右边数格处左对齐。 23  代码行最大长度宜控制在70 至80 个字符以内。代码行不要过长,否 则眼睛看不过来,也不便于打印。 24  长表达式要在低优先级操作符处拆分成新行,操作符放在新行之首(以 便突出操作符)。拆分出的新行要进行适当的缩进,使排版整齐,语句可读。 if ((very_longer_variable1 >= very_longer_variable12) && (very_longer_variable3 <= very_longer_variable14) && (very_longer_variable5 <= very_longer_variable16)) { dosomething(); } virtual CMatrix CMultiplyMatrix (CMatrix leftMatrix, CMatrix rightMatrix); for (very_longer_initialization; very_longer_condition; very_longer_update) { dosomething(); } 25  应当将修饰符 * 和& 紧靠变量名 26  注释是对代码的“提示”,而不是文档。程序中的注释不可喧宾夺主,注释太多了会让人眼花缭乱。注释的花样要少。 27  如果代码本来就是清楚的,则不必加注释。否则多此一举,令人厌烦。 28  边写代码边注释,修改代码同时修改相应的注释,以保证注释与代码的一致性。不再有用的注释要删除。 29  注释应当准确、易懂,防止注释有二义性。错误的注释不但无益反而有害。 30  尽量避免在注释中使用缩写,特别是不常用缩写。 31  注释的位置应与被描述的代码相邻,可以放在代码的上方或右方,不可放在下方。 32  当代码比较长,特别是有多重嵌套时,应当在一些段落的结束处加注释,便于阅读。 33  将public 类型的函数写在前面,而将private 类型的数据写在后面采用这种版式的程序员主张类的设计“以行为为中心”,重点关注的是类应该提供什么样的接口(或服务)。 34  标识符应当直观且可以拼读,可望文知意,不必进行“解码”。标识符最好采用英文单词或其组合,便于记忆和阅读。切忌使用汉语拼音来命名。程序中的英文单词一般不会太复杂,用词应当准确 35  标识符的长度应当符合“min-length && max-information”原则。 36  命名规则尽量与所采用的操作系统或开发工具的风格保持一致。 37  程序中不要出现仅靠大小写区分的相似的标识符。 38  程序中不要出现仅靠大小写区分的相似的标识符。 39  变量的名字应当使用“名词”或者“形容词+名词”。 40  全局函数的名字应当使用“动词”或者“动词+名词”(动宾词组)。       类的成员函数应当只使用“动词”,被省略掉的名词就是对象本身。 41  用正确的反义词组命名具有互斥意义的变量或相反动作的函数等。 42  尽量避免名字中出现数字编号,如Value1,Value2 等,除非逻辑上的确需要编号。这是为了防止程序员偷懒,不肯为命名动脑筋而导致产生无意义的名字(因为用数字编号最省事)。 43  作者对“匈牙利”命名规则做了合理的简化,下述的命名规则简单易用,比较适合 于Windows 应用软件的开发。 44  类名和函数名用大写字母开头的单词组合而成。 45  变量和参数用小写字母开头的单词组合而成。 46  常量全用大写的字母,用下划线分割单词。 47  静态变量加前缀s_(表示static)。 48  如果不得已需要全局变量,则使全局变量加前缀g_(表示global)。 49  类的数据成员加前缀m_(表示member),这样可以避免数据成员与 成员函数的参数同名。 50  为了防止某一软件库中的一些标识符和其它软件库中的冲突,可以为各种标识符加上能反映软件性质的前缀。例如三维图形标准OpenGL 的所有库函数均以gl 开头,所有常量(或宏定义)均以GL 开头。 51  如果代码行中的运算符比较多,用括号确定表达式的操作顺序,避免使用默认的优先级。 52  不要编写太复杂的复合表达式。 53  不要有多用途的复合表达式。 54  不要把程序中的复合表达式与“真正的数学表达式”混淆。 55  不可将布尔变量直接与TRUE、FALSE 或者1、0 进行比较。 56  应当将整型变量用“==”或“!=”直接与0 比较。        不可模仿布尔变量的风格   57  不可将浮点变量用“==”或“!=”与任何数字比较。       假设浮点变量的名字为 x,应当将if (x == 0.0) // 隐含错误的比较转化为if ((x>=-EPSINON) && (x<=EPSINON))       其中EPSINON 是允许的误差(即精度)。                             58  应当将指针变量用“==”或“!=”与NULL 比较。 59  在多重循环中,如果有可能,应当将最长的循环放在最内层,最短的循环放在最外层,以减少CPU 跨切循环层的       次数。      60  如果循环体内存在逻辑判断,并且循环次数很大,宜将逻辑判断移到循环体的外面 61  不可在for 循环体内修改循环变量,防止for 循环失去控制。  62  建议for 语句的循环控制变量的取值采用“半开半闭区间”写法。 63  每个case 语句的结尾不要忘了加break,否则将导致多个分支重叠(除 非有意使多个分支重叠)。 64  不要忘记最后那个default 分支。即使程序真的不需要default 处理,也应该保留语句 default : break; 这样做并非多此一举,而是为了防止别人误以为你忘了default 处理。 65  为什么需要常量     (1) 程序的可读性(可理解性)变差。程序员自己会忘记那些数字或字符串是什么意思,用户则更加不知它们从               何处来、表示什么。     (2) 在程序的很多地方输入同样的数字或字符串,难保不发生书写错误。     (3) 如果要修改数字或字符串,则会在很多地方改动,既麻烦又容易出错。 66  尽量使用含义直观的常量来表示那些将在程序中多次出现的数字或字符串。 67  const 与 #define 的比较       C++ 语言可以用const 来定义常量,也可以用 #define 来定义常量。但是前者比后者有更多的优点:     (1) const 常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误(边际效应)。     (2) 有些集成化的调试工具可以对const 常量进行调试,但是不能对宏常量进行调试。 68  在C++ 程序中只使用const 常量而不使用宏常量,即const 常量完全取代宏常量。 69  需要对外公开的常量放在头文件中,不需要对外公开的常量放在定义文件的头部。为便于管理,可以把不同模块的常量集中存放在一个公共的头文件中。 70  如果某一常量与其它常量密切相关,应在定义中包含这种关系,而不应给出一些孤立的值       const float RADIUS = 100;       const float DIAMETER = RADIUS * 2; 71  有时我们希望某些常量只在类中有效。由于#define 定义的宏常量是全局的,不能达到目的,于是想当然地觉得应该用const 修饰数据成员来实现。const 数据成员的确是存在的,但其含义却不是我们所期望的。const 数据成员只在某个对象生存期内是常量,而对于整个类而言却是可变的,因为类可以创建多个对象,不同的对象其const 数据成员的值可以不同。不能在类声明中初始化const 数据成员。以下用法是错误的,因为类的对象未被创建时,编译器不知道SIZE 的值是什么。 class A {… const int SIZE = 100; // 错误,企图在类声明中初始化const 数据成员 int array[SIZE]; // 错误,未知的SIZE }; const 数据成员的初始化只能在类构造函数的初始化表中进行,例如 class A {… A(int size); // 构造函数 const int SIZE ; }; A::A(int size) : SIZE(size) // 构造函数的初始化表 { … } A a(100); // 对象 a 的SIZE 值为100 A b(200); // 对象 b 的SIZE 值为200 怎样才能建立在整个类中都恒定的常量呢?别指望const 数据成员了,应该用类中的枚举常量来实现。例如 class A {… enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量 int array1[SIZE1]; int array2[SIZE2]; }; 枚举常量不会占用对象的存储空间,它们在编译时被全部求值。枚举常量的缺点是:它的隐含数据类型是整数,其最大值有限,且不能表示浮点数(如PI=3.14159) 72  参数的书写要完整,不要贪图省事只写参数的类型而省略参数名字。如果函数没有参数,则用void 填充。 73  参数命名要恰当,顺序要合理。一般地,应将目的参数放在前面,源参数放在后面。 74  如果参数是指针,且仅作输入用,则应在类型前加const,以防止该指针在函数体内被意外修改。 75  如果输入参数以值传递的方式传递对象,则宜改用“const &”方式来传递,这样可以省去临时对象的构造和析构过程,从而提高效率。    76  避免函数有太多的参数,参数个数尽量控制在5 个以内。如果参数太多,在使用时容易将参数类型或顺序搞错。 77  尽量不要使用类型和数目不确定的参数。 78  不要省略返回值的类型。 79  不要将正常值和错误标志混在一起返回。正常值用输出参数获得,而 错误标志用return 语句返回。 80  有时候函数原本不需要返回值,但为了增加灵活性如支持链式表达,可以附加返回值。 例如字符串拷贝函数 strcpy 的原型: char *strcpy(char *strDest,const char *strSrc); strcpy 函数将strSrc 拷贝至输出参数strDest 中,同时函数的返回值又是strDest。这 样做并非多此一举,可以获得如下灵活性: char str[20]; int length = strlen( strcpy(str, “Hello World”) ); 81 如果函数的返回值是一个对象,有些场合用“引用传递”替换“值传递”可以提高效率。而有些场合只能用“值传递”而不能用“引用传递”,否则会出错。 例如: class String {… // 赋值函数 String & operate=(const String &other); // 相加函数,如果没有friend 修饰则只许有一个右侧参数 friend String operate+( const String &s1, const String &s2); private: char *m_data; } String 的赋值函数operate = 的实现如下: String & String::operate=(const String &other) { if (this == &other) return *this; delete m_data; m_data = new char[strlen(other.data)+1]; strcpy(m_data, other.data); return *this; // 返回的是 *this 的引用,无需拷贝过程 } 对于赋值函数,应当用“引用传递”的方式返回String 对象。如果用“值传递”的 方式,虽然功能仍然正确,但由于return 语句要把 *this 拷贝到保存返回值的外部存储 单元之中,增加了不必要的开销,降低了赋值函数的效率。例如: String a,b,c; … a = b; // 如果用“值传递”,将产生一次 *this 拷贝 a = b = c; // 如果用“值传递”,将产生两次 *this 拷贝 String 的相加函数operate + 的实现如下: String operate+(const String &s1, const String &s2) { String temp; delete temp.data; // temp.data 是仅含‘\0’的字符串 temp.data = new char[strlen(s1.data) + strlen(s2.data) +1]; strcpy(temp.data, s1.data); strcat(temp.data, s2.data); return temp; } 对于相加函数,应当用“值传递”的方式返回String 对象。如果改用“引用传递”, 那么函数返回值是一个指向局部对象temp 的“引用”。由于temp 在函数结束时被自动销 毁,将导致返回的“引用”无效。例如: c = a + b; 此时 a + b 并不返回期望值,c 什么也得不到,留下了隐患。 82   在函数体的“入口处”,对参数的有效性进行检查。很多程序错误是由非法参数引起的,我们应该充分理解并正确使用“来防止此类错误 83  在函数体的“出口处”,对return 语句的正确性和效率进行检查。如果函数有返回值,那么函数的“出口处”是return 语句。我们不要轻视return 语句。如果return 语句写得不好,函数要么出错,要么效率低下。注意事项如下:     (1)return 语句不可返回指向“栈内存”的“指针”或者“引用”,因为该内存在函数体结束时被自动销毁。例如              char * Func(void)             {                  char str[] = “hello world”; // str 的内存位于栈上                  …                  return str; // 将导致错误             }     (2)要搞清楚返回的究竟是“值”、“指针”还是“引用”。     (3)如果函数返回值是一个对象,要考虑return 语句的效率。例如return String(s1 + s2); 这是临时对象的语法,表示“创建一个临时对象并返回它”。不要以为它与“先创建一个局部对象temp 并返回它的结果”是等价的,如 String temp(s1 + s2); return temp; 实质不然,上述代码将发生三件事。首先,temp 对象被创建,同时完成初始化;然后拷贝构造函数把temp 拷贝到保存返回值的外部存储单元中;最后,temp 在函数结束时被销毁(调用析构函数)。然而“创建一个临时对象并返回它”的过程是不同的,编译器直接把临时对象创建并初始化在外部存储单元中,省去了拷贝和析构的化费,提高了效率。 类似地,我们不要将 return int(x + y); // 创建一个临时变量并返回它 写成 int temp = x + y; return temp; 由于内部数据类型如int,float,double 的变量不存在构造函数与析构函数,虽然该“临 时变量的语法”不会提高多少效率,但是程序更加简洁易读。 84  函数的功能要单一,不要设计多用途的函数。 85  函数体的规模要小,尽量控制在50 行代码之内。 86  尽量避免函数带有“记忆”功能。相同的输入应当产生相同的输出。带有“记忆”功能的函数,其行为可能是不可预测的,因为它的行为可能取决于某种“记忆状态”。这样的函数既不易理解又不利于测试和维护。在C/C++语言中,函数的static 局部变量是函数的“记忆”存储器。建议尽量少用static 局部变量,除非必需。 87  不仅要检查输入参数的有效性,还要检查通过其它途径进入函数体内的变量的有效性,例如全局变量、文件句柄等。 88  用于出错处理的返回值一定要清楚,让使用者不容易忽视或误解错误情况。 89  使用断言捕捉不应该发生的非法情况。不要混淆非法情况与错误情况之间的区别,后者是必然存在的并且是一定要作出处理的。 90  在函数的入口处,使用断言检查参数的有效性(合法性)。 91  在编写函数时,要进行反复的考查,并且自问:“我打算做哪些假定?”一旦确定了的假定,就要使用断言对假定进行检查。 92  一般教科书都鼓励程序员们进行防错设计,但要记住这种编程风格可能会隐瞒错误。当进行防错设计时,如果“不可能发生”的事情的确发生了,则要使用断言进行报警。 93  引用的一些规则如下:     (1)引用被创建的同时必须被初始化(指针则可以在任何时候被初始化)。     (2)不能有NULL 引用,引用必须与合法的存储单元关联(指针则可以是NULL)。     (3)一旦引用被初始化,就不能改变引用的关系(指针则可以随时改变所指的对象)。 以下是“值传递”的示例程序。由于Func1 函数体内的x 是外部变量n 的一份拷贝, 改变x 的值不会影响n, 所以n 的值仍然是0。 void Func1(int x) { x = x + 10; } … int n = 0; Func1(n); cout << “n = ” << n << endl; // n = 0 以下是“指针传递”的示例程序。由于Func2 函数体内的x 是指向外部变量n 的指针,改变该指针的内容将导致n 的值改变,所以n 的值成为10。 void Func2(int *x) { (* x) = (* x) + 10; } … int n = 0; Func2(&n); cout << “n = ” << n << endl; // n = 10 以下是“引用传递”的示例程序。由于Func3 函数体内的x 是外部变量n 的引用,x和n 是同一个东西,改变x 等于改变n,所以n 的值成为10。 void Func3(int &x) { x = x + 10; } … int n = 0; Func3(n); cout << “n = ” << n << endl; // n = 10 附一张运算符优先级和结合率的表: 以上这些可能有很多都知道了,但是总有你不知道的!!! 这一章都是一些专题,相比上一章难好多,如果上一章只需要一扫而过,这一章就需要耐心的看和分析了。 高质量编程C\C++编程(二) 1  内存分配方式有三种:   (1) 从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static 变量。   (2) 在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。(包括指针和对象都会被释放)   (3) 从堆上分配,亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存,程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由我们决定,使用非常灵活,但问题也最多。(不管是在哪里进行的new和malloc操作,最后一定要响应的用delete和free来释放掉,否则会产生野指针)   2  常见的内存错误及其对策如下:     ①内存分配未成功,却使用了它。        编程新手常犯这种错误,因为他们没有意识到内存分配会不成功。常用解决办法是,在使用内存之前检查指针是否为NULL。如果指针p 是函数的参数,那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc 或new 来申请内存,应该用if(p==NULL)或if(p!=NULL)进行防错处理。     ②内存分配虽然成功,但是尚未初始化就引用它。        犯这种错误主要有两个起因:一是没有初始化的观念;二是误以为内存的缺省初值全为零,导致引用初值错(例如数组)。内存的缺省初值究竟是什么并没有统一的标准,尽管有些时候为零值,我们宁可信其无不可信其有。所以无论用何种方式创建数组,都别忘了赋初值,即便是赋零值也不可省略,不要嫌麻烦。         (一般需要给指针赋NULL的初值,给数组用malloc(数组名,0,sizeof(数组名)))      ③内存分配成功并且已经初始化,但操作越过了内存的边界。(边界问题)例如在使用数组时经常发生下标“多    1”或者“少1”的操作。特别是在for 循环语句中,循环次数很容易搞错,导致数组操作越界。      ④ 忘记了释放内存,造成内存泄露。含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足,你看不到错误。终有一次程序突然死掉,系统出现提示:内存耗尽。动态内存的申请与释放必须配对,程序中malloc 与free 的使用次数一定要相同,否则肯定有错误(new/delete 同理)。      ⑤ 释放了内存却继续使用它。          有三种情况:        (1)程序中的对象调用关系过于复杂,实在难以搞清楚某个对象究竟是否已经释放了内存,此时应该重新设计数据结构,从根本上解决对象管理的混乱局面。        (2)函数的return 语句写错了,注意不要返回指向“栈内存”的“指针”或者“引用”,因为该内存在函数体结束时被自动销毁。        (3)使用free 或delete 释放了内存后,没有将指针设置为NULL。导致产生“野指针”。 3  C++/C 程序中,指针和数组在不少地方可以相互替换着用,让人产生一种错觉,以为两者是等价的。 数组要么在静态存储区被创建(如全局数组),要么在栈上被创建。数组名对应着(而不是指向)一块内存,其地址与容量在生命期内保持不变,只有数组的内容可以改变。 指针可以随时指向任意类型的内存块,它的特征是“可变”,所以我们常用指针来操作动态内存。指针远比数组灵活,但也更危险。 char a[] = “hello”; a[0] = ‘X’; cout << a << endl; char *p = “world”; // 注意p 指向常量字符串 p[0] = ‘X’; // 编译器不能发现该错误 cout << p << endl; 以下几个例子都是指针和数组的特殊性的例子。 // 数组… char a[] = "hello"; char b[10]; strcpy(b, a); // 不能用 b = a; if(strcmp(b, a) == 0) // 不能用 if (b == a) // 指针… int len = strlen(a); char *p = (char *)malloc(sizeof(char)*(len+1)); strcpy(p,a); // 不要用 p = a; if(strcmp(p, a) == 0) // 不要用 if (p == a) char a[] = "hello world"; char *p = a; cout<< sizeof(a) << endl; // 12 字节 cout<< sizeof(p) << endl; // 4 字节 注意当数组作为函数的参数进行传递时,该数组自动退化为同类型的指针 void Func(char a[100]) { cout<< sizeof(a) << endl; // 4 字节而不是100 字节 } 4  如果函数的参数是一个指针,不要指望用该指针去申请动态内存 void GetMemory(char *p, int num) { p = (char *)malloc(sizeof(char) * num); } void Test(void) { char *str = NULL; GetMemory(str, 100); // str 仍然为 NULL strcpy(str, "hello"); // 运行错误 } 编译器总是要为函数的每个参数制作临时副本,指针 参数p 的副本是 _p,编译器使 _p = p。如果函数体内的程序修改了_p 的内容,就导致 参数p 的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中,_p 申请 了新的内存,只是把_p 所指的内存地址改变了,但是p 丝毫未变。所以函数GetMemory 并不能输出任何东西。事实上,每执行一次GetMemory 就会泄露一块内存,因为没有用 free 释放内存。 如果非得要用指针参数去申请内存,那么应该改用“指向指针的指针” void GetMemory2(char **p, int num) { *p = (char *)malloc(sizeof(char) * num); } void Test2(void) { char *str = NULL; GetMemory2(&str, 100); // 注意参数是 &str,而不是str strcpy(str, "hello"); cout<< str << endl; free(str); } 由于“指向指针的指针”这个概念不容易理解,我们可以用函数返回值来传递动态 内存 char *GetMemory3(int num) { char *p = (char *)malloc(sizeof(char) * num); return p; } void Test3(void) { char *str = NULL; str = GetMemory3(100); strcpy(str, "hello"); cout<< str << endl; free(str); } 用函数返回值来传递动态内存这种方法虽然好用,但是常常有人把return 语句用错了。这里强调不要用return 语句返回指向“栈内存”的指针,因为该内存在函数结束时自动消亡 char *GetString(void) { char p[] = "hello world"; return p; // 编译器将提出警告 } void Test4(void) { char *str = NULL; str = GetString(); // str 的内容是垃圾 cout<< str << endl; } 用调试器逐步跟踪Test4,发现执行str = GetString 语句后str 不再是NULL 指针,但是str 的内容不是“hello world”而是垃圾。 char *GetString2(void) { char *p = "hello world"; return p; } void Test5(void) { char *str = NULL; str = GetString2(); cout<< str << endl; } 函数 Test5 运行虽然不会出错,但是函数GetString2 的设计概念却是错误的。因为GetString2 内的“hello world”是常量字符串,位于静态存储区,它在程序生命期内恒定不变。无论什么时候调用GetString2,它返回的始终是同一个“只读”的内存块。 5  指针p被free 以后其地址仍然不变(非NULL),只是该地址对应的内存是垃圾,p 成了“野指针”。 指针有一些“似是而非”的特征: (1)指针消亡了,并不表示它所指的内存会被自动释放。 (2)内存被释放了,并不表示指针会消亡或者成了NULL 指针。 函数体内的局部变量指针在函数结束时不会自动消亡。 6  malloc和new的差异: class Obj { public : Obj(void){ cout << “Initialization” << endl; } ~Obj(void){ cout << “Destroy” << endl; } void Initialize(void){ cout << “Initialization” << endl; } void Destroy(void){ cout << “Destroy” << endl; } }; void UseMallocFree(void) { Obj *a = (obj *)malloc(sizeof(obj)); // 申请动态内存 a->Initialize(); // 初始化 //… a->Destroy(); // 清除工作 free(a); // 释放内存 } void UseNewDelete(void) { Obj *a = new Obj; // 申请动态内存并且初始化 //… delete a; // 清除并且释放内存 } 类 Obj 的函数Initialize 模拟了构造函数的功能,函数Destroy 模拟了析构函数的功能。函数UseMallocFree 中,由于malloc/free 不能执行构造函数与析构函数,必须调用成员函数Initialize 和Destroy 来完成初始化与清除工作。函数UseNewDelete 则简单得多。既然 new/delete 的功能完全覆盖了malloc/free,为什么C++不把malloc/free 淘汰出 局呢?这是因为C++程序经常要调用C 函数,而C 程序只能用malloc/free 管理动态内存。 如果在申请动态内存时找不到足够大的内存块,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 << “Memory Exhausted” << endl; exit(1); } … } (3)为new 和malloc 设置异常处理函数。例如Visual C++可以用_set_new_hander 函数 为new 设置用户自己定义的异常处理函数,也可以让malloc 享用与new 相同的异常处 理函数。详细内容请参考C++使用手册。 上述(1)(2)方式使用最普遍。如果一个函数内有多处需要申请动态内存,那么方 式(1)就显得力不从心(释放内存很麻烦),应该用方式(2)来处理。 void main(void) { float *p = NULL; while(TRUE) { p = new float[1000000]; cout << “eat memory” << endl; if(p==NULL) exit(1); } } 有一个很重要的现象要告诉大家。对于32 位以上的应用程序而言,无论怎样使用 malloc 与new,几乎不可能导致“内存耗尽”。我在Windows 98 下用Visual C++编写了 测试程序,见示例7-9。这个程序会无休止地运行下去,根本不会终止。因为32 位操作 系统支持“虚存”,内存用完了,自动用硬盘空间顶替。我只听到硬盘嘎吱嘎吱地响, Window 98 已经累得对键盘、鼠标毫无反应。 函数 malloc 的原型如下: void * malloc(size_t size); int *p = (int *) malloc(sizeof(int) * length); malloc 返回值的类型是void *,所以在调用malloc 时要显式地进行类型转换,将void* 转换成所需要的指针类型。 malloc 函数本身并不识别要申请的内存是什么类型,它只关心内存的总字节数。我们通常记不住int, float 等数据类型的变量的确切字节数,所以需要用sizeof进行确认。 如果对象有多个构造函数,那么new 的语句也可以有多种形式。例如 class Obj { public : Obj(void); // 无参数的构造函数 Obj(int x); // 带一个参数的构造函数 … } void Test(void) { Obj *a = new Obj; Obj *b = new Obj(1); // 初值为1 … delete a; delete b; } 如果用new 创建对象数组,那么只能使用对象的无参数构造函数。例如Obj *objects = new Obj[100]; // 创建100 个动态对象不能写成 Obj *objects = new Obj[100](1);// 创建100 个动态对象的同时赋初值1 在用delete 释放对象数组时,留意不要丢了符号‘[]’。例如 delete []objects; // 正确的用法 delete objects; // 错误的用法 后者相当于 delete objects[0],漏掉了另外99 个对象。与malloc相比new方便了很多,也不容易出错,所以尽量要使用new,malloc可以在初始化一些对象上使用。 7  成员函数被重载的特征: (1)相同的范围(在同一个类中); (2)函数名字相同; (3)参数不同; (4)virtual 关键字可有可无。 覆盖是指派生类函数覆盖基类函数,特征是: (1)不同的范围(分别位于派生类与基类); (2)函数名字相同; (3)参数相同; (4)基类函数必须有virtual 关键字。 隐藏: (1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual 关 键字,基类的函数将被隐藏(注意别与重载混淆)。 (2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual 关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。 #include <iostream.h> class Base { public: virtual void f(float x){ cout << "Base::f(float) " << x << endl; } void g(float x){ cout << "Base::g(float) " << x << endl; } void h(float x){ cout << "Base::h(float) " << x << endl; } }; class Derived : public Base { public: virtual void f(float x){ cout << "Derived::f(float) " << x << endl; } void g(int x){ cout << "Derived::g(int) " << x << endl; } void h(float x){ cout << "Derived::h(float) " << x << endl; } }; void main(void) { Derived d; Base *pb = &d; Derived *pd = &d; // Good : behavior depends solely on type of the object pb->f(3.14f); // Derived::f(float) 3.14 pd->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 } // 调用本类型成员函数,隐藏其他 (1)函数Derived::f(float)覆盖了Base::f(float)。 (2)函数Derived::g(int)隐藏了Base::g(float),而不是重载。 (3)函数Derived::h(float)隐藏了Base::h(float),而不是覆盖。 8  参数缺省值只能出现在函数的声明中,而不能出现在定义体中。 例如: void Foo(int x=0, int y=0); // 正确,缺省值出现在函数的声明中 void Foo(int x=0, int y=0) // 错误,缺省值出现在函数的定义体中 { … } 如果函数有多个参数,参数只能从后向前挨个儿缺省,否则将导致函 数调用语句怪模怪样。 正确的示例如下: void Foo(int x, int y=0, int z=0); 错误的示例如下: void Foo(int x=0, int y, int z=0); 不合理地使用参数的缺省值将导致重载函数output 产生二义性。 #include <iostream.h> void output( int x); void output( int x, float y=0.0); void output( int x) { cout << " output int " << x << endl ; } void output( int x, float y) { cout << " output int " << x << " and float " << y << endl ; } void main(void) { int x=1; float y=0.5; // output(x); // error! ambiguous call output(x,y); // output int 1 and float 0.5 } 9  在 C++语言中,可以用关键字operator 加上运算符来表示函数,叫做运算符重载。 例如两个复数相加函数: Complex Add(const Complex &a, const Complex &b); 可以用运算符重载来表示: Complex operator +(const Complex &a, const Complex &b); 运算符与普通函数在调用时的不同之处是:对于普通函数,参数出现在圆括号内; 而对于运算符,参数出现在其左、右侧。例如 Complex a, b, c; … c = Add(a, b); // 用普通函数 c = a + b; // 用运算符 + 如果运算符被重载为全局函数,那么只有一个参数的运算符叫做一元运算符,有两个参数的运算符叫做二元运算符。 如果运算符被重载为类的成员函数,那么一元运算符没有参数,二元运算符只有一个右侧参数,因为对象自己成了左侧参数。                   运算符                                                                             规则           所有的一元运算符                                                       建议重载为成员函数                   = () [] ->                                                              只能重载为成员函数 += -= /= *= &= |= ~= %= >>= <<=                                       建议重载为成员函数              所有其它运算符                                                        建议重载为全局函数 (1)不能改变C++内部数据类型(如int,float 等)的运算符。 (2)不能重载‘.’,因为‘.’在类中对任何成员都有意义,已经成为标准用法。 (3)不能重载目前C++运算符集合中没有的符号,如#,@,$等。原因有两点,一是难以 理解,二是难以确定优先级。 (4)对已经存在的运算符进行重载时,不能改变优先级规则,否则将引起混乱。 10  让我们看看C++ 的“函数内联”是如何工作的。 对于任何内联函数,编译器在符号表里放入函数的声明(包括名字、参数类型、返回值类型)。如果编译器没有发现内联函数存在错误,那么该函数的代码也被放入符号表里。在调用一个内联函数时,编译器首先检查调用是否正(进行类型安全检查,或者进行自动类型转换,当然对所有的函数都一样)。如果正确,内联函数的代码就会直接替换函数调用,于是省去了函数调用的开销。这个过程与预处理有显著的不同,因为预处理器不能进行类型安全检查,或者进行自动类型转换。假如内联函数是成员函数,对象的地址(this)会被放在合适的地方,这也是预处理器办不的。 C++ 语言的函数内联机制既具备宏代码的效率,又增加了安全性,而且可以自由操作类的数据成员。所以在C++ 程序中,应该用内联函数取代所有宏代码,“断言assert”恐怕是唯一的例外。 关键字 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 不应该出现在函数的声明中 内联是以代码膨胀(复制)为代价,仅仅省去了函数调用的开销,从而提高函数的执行效率。如果执行函数体内代码的时间,相比于函数调用的开销较大,那么效率的收 获会很少。另一方面,每一处内联函数的调用都要复制代码,将使程序的总代码量增大,消耗更多的内存空间。以下情况不宜使用内联: (1)如果函数体内的代码比较长,使用内联将导致内存消耗代价较高。 (2)如果函数体内出现循环,那么执行函数体内代码的时间要比函数调用的开销大。 11  String的结构如下: class String { public: String(const char *str = NULL); // 普通构造函数 String(const String &other); // 拷贝构造函数 ~ String(void); // 析构函数 String & operate =(const String &other); // 赋值函数 private: char *m_data; // 用于保存字符串 }; 把对象的初始化工作放在构造函数中,把清除工作放在析构函数中。当对象被创建时,构造函数被自动执行。当对象消亡时,析构函数被自动执行。这下就不用担心忘了对象的初始化和清除工作。 12 构造函数的初始化表 构造函数有个特殊的初始化方式叫“初始化表达式表”(简称初始化表)。初始化表位于函数参数表之后,却在函数体 {} 之前。这说明该表里的初始化工作发生在函数体内的任何代码被执行之前。 构造函数初始化表的使用规则: 如果类存在继承关系,派生类必须在其初始化表里调用基类的构造函数。 例如 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 的构造函数 { … } 在函数的构造函数的过程中一共是分成是两个阶段:变量初始化阶段和计算阶段,初始化阶段先于计算阶段。初始化表主要就是用来初始化类中的成员的。在系统默认类型的初始化上,初始化表和在构造函数中进行初始化的性能差不多,但是在类成员的初始化上,初始化表就展现出了非常大的优势。 以下例子说明: class Test1 { Test1() // 无参构造函数 {cout << "Construct Test1" << endl ;} Test1(const Test1& t1) // 拷贝构造函数 {cout << "Copy constructor for Test1" << endl ;this->a = t1.a ;} Test1& operator = (const Test1& t1) //赋值运算符 {cout << "assignment for Test1" << endl ;this->a = t1.a ;return *this;} int a ; }; struct Test2 { Test1 test1 ; Test2(Test1 &t1) {test1 = t1 ;} }; 调用代码: Test1 t1 ; Test2 t2(t1) ; 输出: Construct Test1 Construct Test1 assignment for Test1 解释一下: 第一行输出对应调用代码中第一行,构造一个Test1对象 第二行输出对应Test2构造函数中的代码,用默认的构造函数初始化对象test1 // 这就是所谓的初始化阶段 第三行输出对应Test2的赋值运算符,对test1执行赋值操作 // 这就是所谓的计算阶段 struct Test2 { Test1 test1 ; Test2(Test1 &t1):test1(t1){} } 使用同样的调用代码,输出结果如下: Construct Test1 Copy constructor for Test1 第一行输出对应 调用代码的第一行 第二行输出对应Test2的初始化列表,直接调用拷贝构造函数初始化test1,省去了调用默认构造函数的过程 所以一个好的原则是,能使用初始化列表的时候尽量使用初始化列表 除了性能问题之外,有些时场合初始化列表是不可或缺的,以下几种情况时必须使用初始化列表 1. 常量成员,因为常量只能初始化不能赋值,所以必须放在初始化列表里面 2. 引用类型,引用必须在定义的时候初始化,并且不能重新赋值,所以也要写在初始化列表里面 3. 没有默认构造函数的类类型,因为使用初始化列表可以不必调用默认构造函数来初始化,而是直接调用拷贝构造函数初始化 struct Test1 { Test1(int a):i(a){} int i; }; struct Test2 { Test1 test1 ; Test2(Test1 &t1) {test1 = t1;} }; 以上代码无法通过编译,因为Test2的构造函数中test1 = t1这一行实际上分成两步执行: 1. 调用Test1的默认构造函数来初始化test1 2. 调用Test1的赋值运算符给test1赋值 但是由于Test1没有默认的构造函数,所谓第一步无法执行,故而编译错误。正确的代码如下,使用初始化列表代替赋值操作 struct Test2 { Test1 test1 ; Test2(Test1 &t1):test1(t1){} } 成员是按照他们在类中出现的顺序进行初始化的,而不是按照他们在初始化列表出现的顺序初始化的,看代码: struct foo { int i ;int j ; foo(int x):i(x), j(i){}; // ok, 先初始化i,后初始化j }; 再看下面的代码: struct foo { int i ;int j ; foo(int x):j(x), i(j){} // i值未定义 }; 这里i的值是未定义的因为虽然j在初始化列表里面出现在i前面,但是i先于j定义,所以先初始化i,而i由j初始化,此时j尚未初始化,所以导致i的值未定义。一个好的习惯是,按照成员定义的顺序进行初始化。 由于并非所有的对象都会使用拷贝构造函数和赋值函数,程序员可能对这两个函数有些轻视。请先记住以下的警告,在阅读正文时就会多心: 开头讲过,如果不主动编写拷贝构造函数和赋值函数,编译器将以“位拷贝”(又称浅拷贝)的方式自动生成缺省的函数。倘若类中含有指针变量,那么这两个缺省的函数就隐含了错误。以类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) 以区别于第四个语句。 浅拷贝和深拷贝  在某些状况下,类内成员变量需要动态开辟堆内存,如果实行位拷贝,也就是把对象里的值完全复制给另一个对象,如A=B。这时,如果B中有一个成员变量指针已经申请了内存,那A中的那个成员变量也指向同一块内存。这就出现了问题:当B把内存释放了(如:析构),这时A内的指针就是野指针了,出现运行错误。      深拷贝和浅拷贝的定义可以简单理解成:如果一个类拥有资源(堆,或者是其它系统资源),当这个类的对象发生复制过程的时候,这个过程就可以叫做深拷贝,反之对象存在资源,但复制过程并未复制资源的情况视为浅拷贝。      浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。 13示例:类String 的拷贝构造函数与赋值函数 // 拷贝构造函数 String::String(const String &other) { // 允许操作other 的私有成员m_data int length = strlen(other.m_data); m_data = new char[length+1]; strcpy(m_data, other.m_data); } // 赋值函数 String & String::operate =(const String &other) { // (1) 检查自赋值 if(this == &other) return *this; // (2) 释放原有的内存资源 delete [] m_data; // (3)分配新的内存资源,并复制内容 int length = strlen(other.m_data); m_data = new char[length+1]; strcpy(m_data, other.m_data); // (4)返回本对象的引用 return *this; } 类 String 拷贝构造函数与普通构造函数(参见9.4 节)的区别是:在函数入口处无需与NULL 进行比较,这是因为“引用”不可能是NULL,而“指针”可以为NULL。 类 String 的赋值函数比构造函数复杂得多,分四步实现: (1)第一步,检查自赋值。你可能会认为多此一举,难道有人会愚蠢到写出 a = a 这样的自赋值语句!的确不会。但是间接的自赋值仍有可能出现,例如 // 内容自赋值 b = a; … // 地址自赋值 b = &a; … c = b; … a = c; a = *b; 也许有人会说:“即使出现自赋值,我也可以不理睬,大不了化点时间让对象复制自己而已,反正不会出错!” 他真的说错了。看看第二步的delete,自杀后还能复制自己吗?所以,如果发现自赋值,应该马上终止函数。注意不要将检查自赋值的if 语句 if(this == &other) 错写成为 if( *this == other) (2)第二步,用delete 释放原有的内存资源。如果现在不释放,以后就没机会了,将造成内存泄露。 (3)第三步,分配新的内存资源,并复制字符串。注意函数strlen 返回的是有效字符串长度,不包含结束符‘\0’。函数strcpy 则连‘\0’一起复制。 (4)第四步,返回本对象的引用,目的是为了实现象 a = b = c 这样的链式表达。注意不要将 return *this 错写成 return this 。那么能否写成return other 呢?效果不是一样吗? 不可以!因为我们不知道参数other 的生命期。有可能other 是个临时对象,在赋值结束后它马上消失,那么return other 返回的将是垃圾。 偷懒的办法是:只需将拷贝构造函数和赋值函数声明为私有函数,不用编写代码。 例如: class A { … private: A(const A &a); // 私有的拷贝构造函数 A & operate =(const A &a); // 私有的赋值函数 }; 如果有人试图编写如下程序: A b(a); // 调用了私有的拷贝构造函数 b = a; // 调用了私有的赋值函数 编译器将指出错误,因为外界不可以操作 A 的私有函数。 14如何在派生类中实现类的基本函数 基类的构造函数、析构函数、赋值函数都不能被派生类继承。如果类之间存在继承关系,在编写上述基本函数时应注意以下事项: 派生类的构造函数应在其初始化表里调用基类的构造函数。 基类与派生类的析构函数应该为虚(即加virtual 关键字)。例如 #include <iostream.h> 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 & operate =(const Base &other); // 类Base 的赋值函数 private: int m_i, m_j, m_k; }; class Derived : public Base { public: … Derived & operate =(const Derived &other); // 类Derived 的赋值函数 private: int m_x, m_y, m_z; }; Derived & Derived::operate =(const Derived &other) { //(1)检查自赋值 if(this == &other) return *this; //(2)对基类的数据成员重新赋值 Base::operate =(other); // 因为不能直接操作私有数据成员 //(3)对派生类的数据成员赋值 m_x = other.m_x; m_y = other.m_y; m_z = other.m_z; //(4)返回本对象的引用 return *this; } 如果类A 和类B 毫不相关,不可以为了使B 的功能更多些而让B继承A 的功能和属性。不要觉得“白吃白不吃”,让一个好端端的健壮青年无缘无故地吃人参补身体。 若在逻辑上B 是A 的“一种”(a kind of ),则允许B 继承A 的功能和属性。例如男人(Man)是人(Human)的一种,男孩(Boy)是男人的一种。那么类Man 可以从类Human 派生,类Boy 可以从类Man 派生。 注意事项 看起来很简单,但是实际应用时可能会有意外,继承的概念在程序世界与现实世界并不完全相同。 所以更加严格的继承规则应当是:若在逻辑上B 是A 的“一种”,并且A 的所有功能和属性对B 而言都有意义,则允许B 继承A 的功能和属性。 若在逻辑上A 是B 的“一部分”(a part of),则不允许B 从A 派生,而是要用A 和其它东西组合出B。 15  看到 const 关键字,C++程序员首先想到的可能是const 常量。这可不是良好的条件反射。如果只知道用const 定义常量,那么相当于把火药仅用于制作鞭炮。const 更大的魅力是它可以修饰函数的参数、返回值,甚至函数的定义体。 const 是constant 的缩写,“恒定不变”的意思。被const 修饰的东西都受到强制保护,可以预防意外的变动,能提高程序的健壮性。所以很多C++程序设计书籍建议:“Use constwhenever you need”。 用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)。同理不要将函数voidFunc2(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)。 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; } 16  最后的一些建议: ◆不要一味地追求程序的效率,应当在满足正确性、可靠性、健壮性、可读性等质量因素的前提下,设法提高程序的效率。 ◆以提高程序的全局效率为主,提高局部效率为辅。 ◆在优化程序的效率时,应当先找出限制效率的“瓶颈”,不要在无关紧要之处优化。 ◆先优化数据结构和算法,再优化执行代码。 ◆有时候时间效率和空间效率可能对立,此时应当分析那个更重要, ◆作出适当的折衷。例如多花费一些内存来提高性能。 ◆不要追求紧凑的代码,因为紧凑的代码并不能产生高效的机器码。当心那些视觉上不易分辨的操作符发生书写错误。 ◆我们经常会把“==”误写成“=”,象“||”、“&&”、“<=”、“>=”这类符号也很容易发生“丢1”失误。然而编译器却不一定能自动指出这类错误。 ◆变量(指针、数组)被创建之后应当及时把它们初始化,以防止把未被初始化的变量当成右值使用。 ◆当心变量的初值、缺省值错误,或者精度不够。 ◆当心数据类型转换发生错误。尽量使用显式的数据类型转换(让人们知道发生了什么事),避免让编译器轻悄悄地进行隐式的数据类型转换。 ◆当心变量发生上溢或下溢,数组的下标越界。 ◆当心忘记编写错误处理程序,当心错误处理程序本身有误。 ◆当心文件I/O 有错误。 ◆避免编写技巧性很高代码。 ◆不要设计面面俱到、非常灵活的数据结构。 ◆如果原有的代码质量比较好,尽量复用它。但是不要修补很差劲的代码,应当重新编写。 ◆尽量使用标准库函数,不要“发明”已经存在的库函数。 ◆尽量不要使用与具体硬件或软件环境关系密切的变量。 ◆把编译器的选择项设置为最严格状态。 ◆如果可能的话,使用PC-Lint、LogiScope 等工具进行代码审查。

上一篇:SQL中的where条件提取
下一篇:C Static 和 Const 区别

相关文章

相关评论