c/c++高质量编程

第一章    文件结构

1.1为了防止头文件的重复引用，应当用ifndef/define/endif 结构产生预处理快。

  eg:

#ifndef FILE_H//防止file.h被重复引用

#define FILE_H

……

#endif

 

1.2#include<filename.h>引用标准库的头文件，编辑器将从标准库开始搜索。

1.3#include"filename.h“引用非标准库的头文件，编辑器将从用户的工作目录开始搜索。

1.4头文件的作用

1.通过头文件调用库的功能。

2.头文件可以加强安全问题检查。

1.6目录结构：

一个软件如果包含的头文件过多时（假如超过10个），不管是标准库头文件还是自定义的头文件，应该放入到不同的目录中，以便维护。

 

第二章 程序的版式

2.1 空行 

每个类的声明之后，和函数的定义之后都要加空行

2.2代码行

一行代码只做一件事，例如，只定义一个变量或者只写一条语句。

2.3代码行中的空格

2-3-1关键字之后保留空格。const,virtual,inline之后至少要保留一个空格。像if,while,for关键字之后应该保留一个空格之后再跟"{",突出关键字。

2-3-2 "，"之后要留空格。eg：int func(x, y, z);   "；"不是一行中的最后结束符号，之要保留空格。

2-3-3 二元操作符前后要加上空格。

2.4长行拆分

2-4-1代码行最大长度控制在70~80个字符以内。

2--4-2长代码行应该在低优先级运算符处拆分新行，操作符放在新行之首。

eg:if ((very_longer_variable1 >= very_longer_variable12)

          && (very_longer_variable3 <= very_longer_variable14)

          && (very_longer_variable5 <= very_longer_variable16))

         {    

           dosomething(); 

          } 

2.5修饰符的位置

2-5-1修饰符 * 和 & 应该仅靠变量名 eg : char *name;   

 

第三章 命名规则

3.1

3-1-1常量全用大写字母表示，用下划线分割单词。

eg:const int MAX = 100;

      const int MAX_LENGTH = 200;

3-1-2静态变量前面加上 s_(表示static)

3-1-3全局变量前面加上g_(表示global)

 

第四章 表达式和基本语句

4.1运算符的优先级

由高至低  () [] -> .                                                                  结合律

                 !  ~ ++ -- sizeof + - * &                                           由右至左

                 *  /  % 

                 +  -

                  <<    >> 

                  <   <=  >=   >

                  ==      !=

                  &

                  ^

                  |

                  &&

                   ||                                                                           由右至左

                   ? :                                                                         由右至左

                   += -=  *= /= &= ^= 

4.2不要写多用途复合表达式

eg:if( a > b > c)并不表示 if( ( a > b) && ( b > c)) 而是 if(( a >b) > c)

4.3if语句

4-3-1 布尔类型与零值比较

if(flag)//表示flag为真

if(!flag)//表示flag为假

不良的风格：

if(flag == 1)

if(flag == TRUE)

if(flag == FALSE)

if(flag == 0)

4-3-2整形与零值比较

if(value == 0)

if(balue != 0)

4-3-3浮点数与零值比较

if( (value >= -EOF) && (value <= EOF))//EOF是允许的误差

4.4循环语句的效率

4-4-1 for循环次数多的语句放在内部，循环次数少的语句放在外部。

4-4-2如果循环体内部存在逻辑判断，且循环次数很多时，应该把逻辑判断放在循环体外部。

第五章 常量

5.1为什么使用常量？

1.如果不使用常量，直接在程序里面写数字或者字符串，程序的可读性变差，程序员自己会忘记数字或者字符串什么意思。

2.用户在多个地方输入数字或者字符串时，难免会出错。

3.如果要修改数字或者字符串时，要多次修改。

5.2const和define的区别

c++语言既可以用const修饰常量也可以用define修饰常量。但是const常量有以下优点：

1.const常量有数据类型，而宏没有数据类型。

2.有些集成化额调试工具对const有调试作用，而对宏常量不具调试作用。

5.3类中的常量

define定义的常量是全局变量，不能达到目的。const只是在某个对象生存周期内是常量，而对于整个类而言是可变的，一个类可以有多个对象，所以const常量可以有 不同的值。

不能在类的声明中初始化const数据成员。

const数据成员的初始化只能在类的构造函数的初始化列表中进行。

怎样才能建立类中都恒定不变的常量呢？不要指望const数据成员了，要依靠枚举类型来实现。

class A  

{…  

     enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量  

      int array1[SIZE1];  
 
      int array2[SIZE2];  

};

枚举常量不会占用对象的存储空间，它们在编译时被全部求值。枚举常量的缺点是： 它的隐含数据类型是整数，其大值有限。

 

第六章 函数设计

6.1参数的规则

6-1-1参数的书写要完整，不能省略。如果没有参数，要用void填充。

6-1-2参数命名要恰当，顺序要合理。

6-1-3参数是指针，且仅作输入用，则应在参数前面加上const,以防止该指针在函数体内被修改。

6-1-4如果输入参数以值传递的方式传递对象，应该用const &的方式来传递，这样可以省去临时对象构造函数和析构函数的创建，从而提高效率。

6.2程序分为Debug版本和Relese版本，Debug版本用于内部调试，Relese版本发行给用户使用。

assert断言是仅在Debug版本起作用的宏。

6.3引用和断言的比较

eg:n是m的一个引用，m是被引用物。

int m;

int &n = m;

引用规则如下：

1.引用在创建时必须被初始化（指针可以在任何时候）

2.不能有NULL引用，引用必须与合法的存储单元关联（指针可以是NULL）

3.一旦引用初始化，就不能改变引用的关系。（指针则可以随时改变所指的对象）

函数的参数和返回值有三种：值传递，引用传递，指针传递

 

第七章 内存管理

7.1内存分配方式三种：

（1）从静态存储区域分配。

（2）在栈上创建。

（3）从堆上分配，亦称动态内存分配。

7.2常见的内存错误及对策

（1）内存分配未成功，却使用了它。（要进行防错处理。）

（2）内存分配虽然成功，但尚未初始化就引用它。

（3）内存分配成功并且已经初始化，但操作越过了内存的边界。

（4）忘记释放内存，造成内存泄漏。

（5）释放内存，却继续使用它。（含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你 看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。） 

（6）释放了内存，却继续使用它。（用free或者delete释放内存之后 ，没有将指针置为NULL，造成"野指针"）

7.3指针与数组的对比

数组要么在静态存储区，要么在栈区。数组名对应一块内存地址，其地址和容量在其生命周期内不变，数组的内容可变。

指针可以指向任意类型的内存块，他的特征是可变。所以我们常用指针操作动态内存。

7-3-1修改内容

数组的值可变，指针常量的值不变。

7-3-2内容复制与比较

不能对数组名进行直接复制和比较。要调用函数strmcpy()和strcmp()

7-3-3计算内存容量

用sizeof()计算数组的容量（字节数）。

7-3-4

7.4动态内存会被自动释放吗？

（1）指针消亡不代表内存释放。

（2）内存释放，不代表指针释放。

7.5野指针原因：

（1）指针创建时没有被初始化，不会自动生成NULL指针。缺省值随机的，会乱指一通。

（2）指针被free或者delete后，没有置NULL。

  (3)指针操作超出了变量的作用范围。（块函数内的指针变量，在块函数外再进行操作就是野指针）

7.6有了malloc/free  为什么还要有new/delete?

malloc/free是c/c++ 错的标准库，new/delete 是c++的运算符。都可以动态申请内存和释放内存。

（1）但是malloc/free无法满足动态对象的要求。对象在创建时要自动执行构造函数，在对象消亡时要自动执行析构函数。malloc/free是库函数，编译器没有控制权限，无法把执行构造函数以及析构函数的任务强加到malloc/free。

（2）因此c++需要一个能完成动态内存分配和初始化的运算符new,以及一个能清理及释放内存的运算符delete。

7.7如何有效处理内存耗尽的问题？

如果在申请动态内存时找不到足够大的内存块，malloc和new将返回NULL指针，宣告内存申请失败。通常有三种方式处理“内存耗尽”问题。

（1）判断指针是否为NULL，如果是则马上用return语句终止本函数。

（2）判断指针是否为NULL，如果是则马上用exit(1)终止整个程序的运行。

（3）为new和malloc设置异常处理函数。例如Visual C++可以用_set_new_hander函数为new设置用户自己定义的异常处理函数，也可以让malloc享用与new相同的异常处理函数。

7.8new/delete的使用要点

7-8-1运算符 new 使用起来要比函数 malloc 简单得多，

eg： int  *p1 = (int *)malloc(sizeof(int) * length);

         int  *p2 = new int[length]; 

7-8-2如果用new创建对象数组，那么只能使用无参数的构造函数，

 

第八章 c++函数的高级特性

8.1函数重载的概念

8-1-1函数重载是指在同一作用域内，可以有一组具有相同函数名，不同参数列表的函数，这组函数被称为重载函数

c++采用重载机制理由：

(1)c++语言要求类名和构造函数名要一样，构造函数只能有一个名字。那么想要实例化很多对象，那相当麻烦。

(2)把具有相近语义及相同功能的函数用同一名字表示，便于记忆，简单了许多。

8-1-2重载如何实现

函数的两个接口：参数和返回值

同名的函数很好区分：如果同名参数不同（包括类型和顺序不同，函数不同）

仅仅时返回值不同，有时可以区分，有时则不可以。

c++编译器如果要调用编译后的C函数，如何解决？

c++提供了一个连接c交换指定符号"exteren C"

8.2成员函数的重载，覆盖，和隐藏

8-2-1重载与覆盖

成员函数被重载的特征：

（1）同一类中

（2）函数名字相同

（3）参数不同

（4）Virtual关键字可有可无

覆盖是指派生类函数覆盖基类函数，特征：

（1）不同的范围

（2）函数名字相同

（3）函数的参数相同

（4）基类函数必须有Virtual关键字

8-2-2隐藏规则（重载和覆盖区别并不难，但是加上隐藏问题就变复杂了）

（1）派生类和基类的函数名相同，参数不同，不管基类函数是否有Virtual关键字，基类函数将被隐藏。

（2）派生类和基类的函数名相同，参数相同，但是基类函数没有Virtual关键字，基类函数将被隐藏。

8.3参数的缺省值

参数的缺省值只能出现下函数的声明中，不能出现在函数的定义中。

如果函数有多个参数，参数只能从后向前缺省

不合理的缺省使函数重载产生二义性。

8.4运算符重载

8-4-1 概念

关键字operator+运算符来表示函数，叫做运算符的重载。

运算符与普通函数调用时的不同：对于普通函数，参数调用出现在圆括号内，对于运算符，参数出现在运算符两侧。 

运算符函数既可以定义为全局函数，也可以定义为成员函数
 
运算符                                                                               规则

所有的一元运算符                                                  建议重载为成员函数

= () [] ->                                                                 只能重载为成员函数

+= -= /= *= &= |= ~= %= >>= <<=                         建议重载为成员函数

所有其它运算符                                                     建议重载为全局函数 

8-4-2 不能被重载的运算符

（1）不能改变c++内部函数数据类型（int， char）的运算符

  (2)不能重载".","."对任何成员函数都有意义

（3）对已经存在的运算符重载，不能改变优先级

8.5函数内联（inline）

8-5-1用内联取代宏代码

目的是提高函数的执行效率。

在C语言中，用宏提高执行效率。用宏替代函数调用，省去了参数入栈，生成汇编语言的CALL调用，返回参数，执行return等。但是宏代码的缺陷容易出错。

eg: #define MAX(a,b)  (a) > (b) ? (a) : (b)

       result = MAX( i，j) + 2;

       而 “+” 的优先级比 “：”的优先级高，所以先执行。

修改 #define MAX(a,b)  ((a) > (b) ? (a) : (b))就可以避免错误

使用宏代码还有一缺点：无法操作类的私有数据成员

C++ 语言的函数内联机制既具备宏代码的效率，又增加了安全性，而且可以自由操 作类的数据成员。

8-5-2内联函数如何工作？

对于任何内联函数，在符号表里放入函数的声明（包括名字，参数类型，返回值类型），内联函数是成员函数，对象的地址会被放在合适的地方。所以在 C++ 程序中，应该用内联函数取代所有宏代码，“断言 assert” 恐怕是唯一的例外。

内联函数不应该在函数的声明中，而是在定义中，（因为函数的定义用户不用看到，用户也不需要知道是否使用内联函数，用户只接触声明，所以内联体现在定义中即可。

8-5-3 慎用内联函数

内联函数可以提高函数执行效率，内联函数是复制代码到函数体中，以此来代替函数调用，提高效率。但是并不是内联函数一定会提高函数执行效率，当执行复制的代码量大于函数调用的开销时，效率就没有提升，并且复制代码会造成内存消耗。

 

第 9 章 类的构造函数、析构函数与赋值函数

每个类只有一个析构函数和一个赋值函数，但可以有多个构造函数（包含一个拷贝 构造函数，其它的称为普通构造函数）。对于任意一个类 A，如果不想编写上述函数， C++编译器将自动为 A 产生四个缺省的函数，如

 A(void);     // 缺省的无参数构造函数  

A(const A &a);    // 缺省的拷贝构造函数

 ~A(void);     // 缺省的析构函数  

A & operate =(const A &a); // 缺省的赋值函数 

9.1 构造函数与析构函数的起源 

C语言在编译时产生大量的未初始化及清除的错误，但是编译器无法判断识别，造成程序安全隐患。c++为了提高程序的安全性，引入构造函数和析构函数，把对象的初始化工作放在构造函数中，把清除工作放在析构函数中。当对象被创建时，构造函数被自动执行。当对象消亡时，析构函数被自动执行。这下就不用担心忘了对象的初始化和清除工作。 

9.2 构造函数的初始化表 

（1）如果类存在继承关系，派生类必须在其初始化表里调用基类的构造函数。

  (2）类的数据成员的初始化可以采用初始化表或函数体内赋值两种方式，这两种方式的 效率不完全相同。 

  (3)类的 const 常量只能在初始化表里被初始化，因为它不能在函数体内用赋值的方式 来初始化

9.3不要轻视拷贝构造函数与赋值函数 

(1)如果不主动编写拷贝构造函数和赋值函数，编译器将以“位拷贝” 的方式自动生成缺省的函数。

(2）拷贝构造函数是在对 象被创建时调用的，而赋值函数只能被已经存在了的对象调用。

9.4 示例：类 String 的拷贝构造函数与赋值函数 

类 String 拷贝构造函数与普通构造函数的区别是：在函数入口处无 需与 NULL 进行比较，这是因为“引用”不可能是 NULL，而“指针”可以为 NULL。

类 String 的赋值函数比构造函数复杂得多，分四步实现：

（1）第一步，检查自赋值。eg:if(this == &other) 错写成为  if( *this == other)

（2）第二步，用 delete 释放原有的内存资源。

（3）第三步，分配新的内存资源，并复制字符串。

（4）第四步，返回本对象的引用，目的是为了实现象 a = b = c 这样的链式表达。

9.5 如何在派生类中实现类的基本函数 

基类的构造函数、析构函数、赋值函数都不能被派生类继承。

 派生类的构造函数应在其初始化表里调用基类的构造函数。  

基类与派生类的析构函数应该为虚（即加 virtual 关键字）。

 在编写派生类的赋值函数时，注意不要忘记对基类的数据成员重新赋值。

 

第 10 章 类的继承与组合 

10.1继承

10-1-1如果类 A 和类 B 毫不相关，不可以为了使 B 的功能更多些而让 B 继承 A 的功能和属性。

10-1-2若在逻辑上 B 是 A 的“一种” （a kind of ），则允许 B 继承 A 的功能和属性。

所以更加严格的继承规则应当是：若在逻辑上 B 是 A 的“一种”，并且 A 的所有功 能和属性对 B 而言都有意义，则允许 B 继承 A 的功能和属性。

10.2 组合 

10-2-1若在逻辑上 A 是 B 的“一部分” （a part of），则不允许 B 从 A 派生， 而是要用 A 和其它东西组合出 B。 

第十一章 额外

11-1-1 用 const 修饰函数的参数如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传递”，都不能加 const 修饰，否则该参数将失去输出功能。

const 只能修饰输入参数：如果输入参数采用“指针传递”，那么加 const 修饰可以防止意外地改动该指针，起到保护作用。

 11-1-2如果给以“指针传递”方式的函数返回值加 const 修饰，那么函数返回值（即指针） 的内容不能被修改，该返回值只能被赋给加 const 修饰的同类型指针。 

 11-1-3如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加 const 修饰没有任何价值。

 函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达。

11-1-4const 成员函数的声明看起来怪怪的：const 关键字只能放在函数声明的尾部