高质量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

附一张运算符优先级和结合率的表：

以上这些可能有很多都知道了，但是总有你不知道的！！！