高质量C++编程指南学习笔记

 

1.1 文件结构

1.1.1 版权和版本的声明

版权和版本声明位于头文件或者实现文件的开头，具体内容包括：

Ø        版权信息

Ø        文件名称、标识符和摘要

Ø        当前版本号，作者/修改者，完成日期

Ø        版本的历史信息

例如以下模板：

/*

* Copyright (c) 2007,长沙威胜电子有限公司电能质量事业部

* All rights reserved.

*

* 文件名称：filename.h

* 文件标识：见配置管理计划书

* 摘    要：简要描述本文件的内容

*

* 当前版本：1.1

* 作    者：输入作者（或修改者）名字

* 完成日期： 2007 年 6 月 18 日

*

* 取代版本：1.0

* 原作者 ：输入原作者（或修改者）名字

* 完成日期： 2007 年 6 月 10 日

*/

1.1.2 头文件的结构

头文件的结构包括三个部分：

²       版权和版本说明（参见1.1.1）

²       预处理块

²       数据结构和函数声明

为防止头文件被重复引用，每一个头文件要用#ifndef/#define/#endif结构产生预处理块；

以#include <stdio.h>形式引用头文件时，编译器将从头文件的标准库目录中搜寻该文件，以#include “stdio.h”形式引用头文件时，编译器将从程序目录中搜寻该文件；

为便于管理以及实现信息隐藏之目的，头文件中只存放函数的声明而不存放函数的实现代码；

尽量不要在头文件中使用全局变量，如extern int a等。

1.1.3 实现文件的结构

定义文件也包括三部分，即：

Ø        版权和版本声明（参见1.1.1）

Ø        对相应头文件的引用

Ø        数据及实现代码

1.1.4 头文件的作用

头文件主要有以下作用：

²       可以用头文件来调用标准库功能，实现代码的隐藏

²       头文件能加强入口参数类型检查

1.1.5 目录结构

为方便代码的管理，可以将程序的头文件放在include目录下，将实现文件放在source目录下。

1.2 程序的版式

程序的版式主要是为使程序结构清晰明了而作的工作，例如适当的空行和对齐（长行拆分，短行不要合并）可以使程序更容易理解。

函数之间要有空行，函数内逻辑关系进的语句之间不要空行，逻辑关系不紧密的语句之间要加空行。每一个语句段（‘{}’括起来的语句）要将‘{’和‘}’对齐。各个代码段要缩进对齐，如以下代码：

void main()

{

    int sum = 0;

 

    for (int i=0; i<10; i++)

{

        sum += I;

}

}

void main(){

 

    int sum = 0;

 

    for (int i=0; i<10; i++){

 

        sum += I;

}

}

很明显第一个mian函数的结构更加清晰。

 

变量一定要赋初值，当然这里的一定其实不一定，但是为防止在程序运行时出现莫名其妙又很难查到的bug，则很有可能是由于变量未赋初值引起的。所以在声名变量时对齐赋初值是一个很好的习惯。

 

修饰符的位置因人而异，例如以下两种声明变量的方法：

int* p;

int *p;

当用第一种方法声明时，如果同时声明两个变量，则容使人误解。如：

int* p, q; //容易使人误以为q也是int型指针变量

 

适当的注释是使程序容易理解最好的手段，但注释不要太过琐碎。但注释要写的准确和简洁，容易引起误解的注释无胜于有。

 

类的版式有两种：

Ø        以数据为中心的人会把类中的变量定义放在前面

Ø        以行为为中心的人会把类中的函数定义放在前面

我们要以行为为中心，加入我们要做一个标准库，则提供给别人的都是方法的接口，别人并不关心你的方法是如何实现的（也没有必要）。

1.3 命名规则

1.3.1 共性规则

所谓共性规则就是被广大程序员所接纳的规则，如：

l        标识符应直观可读，可望文知意

很多中国的程序员以拼音命名法，当然这种方法肯定是有其不合理之处，但是仍为很多人所用，何解？

l        标识符应符合max-length和max-information原则

l        命名规则应尽量和操作系统和开发工具的命名规则保持一致

例如Windows操作系统的函数一般是大小写结合的方式，如AddNode()，而Linux操作系统则一般采用下划线连接的方式，如add_node()。

l        程序中不要出现仅仅以大小写区分的函数或变量

l        类名、结构体名和函数名以大写开头，大小写结合的方式，变量名以小写开头，大小写结合的方式？

l        const常量全部以大写命名，静态变量以s_开头，全局变量以g_开头

l        类的成员变量以m_开头，表示为类的成员(member)

1.3.2 团队规则

    团队进行开发之前，在遵照以上标准的前提下，应该给全体成员提供代码撰写规则文档。

1.4 表达式和基本语句

1.4.1 运算符优先级

有一个最简单的不用记运算符优先级的方法就是使用括号，但是过度的使用括号会使程序看起来晦涩难懂，所以适当的记住一些运算符优先级是有必要的。

一些记忆优先级的准则：

Ø        一元运算符的优先级高于二元运算符

Ø        算数运算符优先级高于逻辑运算符

Ø        ()、[]、->和“.”运算符的优先级最高

1.4.2 复合表达式

例如以下赋值语句：

a = b = c = 1;

是一个完全正确的赋值语句，但最好不要用这种复合型的表达式，而应该分别赋值。

1.4.3 if语句

if语句中变量值与零值的比较：

Ø        布尔变量与零值比较

if (flag)或if (!flag)

Ø        整型值与零值比较

if (x == 0)或if (x != 0)

Ø        浮点值与零值比较

if (x >= -EPSINON) && (x <= EPSINON)，即对浮点型数据要允许一定的精度偏差，EPSINON即为偏差精度。

Ø        指针与零值比较

if (p == NULL)或if (p != NULL)

 

if语句段中包含return语句：

if (condition)

{

    return x;

}

else

{

    return y;

}

if (condition)

{

    return x;

}

 

 

return y;

 

以上左边为规则的写法，右边为不规则的写法，更为简洁的写法是：return (condition ? x:y)

1.4.4 循环语句的效率

如果程序中包含多重循环，循环的顺寻为由内到外循环次数逐渐减少，即将循环次数最多的循环放在最里面。

如果循环体内包含逻辑判断，则在循环次数较多时须将逻辑判断放在循环外部，否则会打断CPU的流水线作业。

对for循环语句，尽量不要在循环内部修改循环变量的值。

1.4.5 switch语句

合理的利用switch可以使程序更简洁。不要忘记每一个case的break语句，除非有意为之。

1.4.6 goto语句

尽量少用或者不用goto语句，但是在特殊情况下利用goto语句能起到意想不到的效果，例如跳出多重循环，否则则需要很多的break语句来完成此功能。

1.5 常量

尽量将程序中用到次数很多的不变值的变量定义为const常量，这样一旦该变量值发生改变，则只需要修改常量定义即可。

1.5.1 #define与const常量

尽量定义const常量，原因是const常量带类型，而#define常量不带类型，而且有些调试器可以调试const常量，但是#define常量不可以调试。

常量值如果密切相关的话，应在定义时包括这种关联关系，而不要分别赋值，如：

const float R = 10.0;

const float PI = 3.14;

const float AREA = PI * R * R;

1.5.2 类中的常量

类中的const常量只能在类的构造函数的初始化表中赋值，如：

class A

{⋯

A(int size); // 构造函数

const int SIZE ;

};

A::A(int size) : SIZE(size) // 构造函数的初始化表

{

⋯

}

A a(100); // 对象 a 的SIZE 值为100

整个类中值固定的常量只能通过枚举变量实现，enum( RED = 1; BLUE = 2)，但是枚举常量只能为短整型，这是其不足之处。

1.6 函数设计

函数接口的两个要素是参数和返回值，C++中的参数有三种传递方式，值传递、指针传递和引用传递。

1.6.1 参数规则

参数的命名要简洁规范，在声名函数时，要将参数名称写完整，如果函数没有参数，则要用void补充。

函数参数的顺序安排要合理，如字符串拷贝函数strcpy(char* pDst,const char* pSrc)，如果写成了strcpy(const char* pSrc, char* pDst)，则别人用该函数时很可能顺手写成strcpy(szNew,szOld)，从而颠倒了参数的调用。

如果函数输入参数为指针，且仅作输入用，则应加const修饰，防止被以外修改。

如果函数输入参数为值传递，应用const &修饰，以增强函数的执行效率。

避免使用过多的输入参数。

1.6.2 返回值规则

不要图省事而省略参数的返回值，如果确实没有返回值，则应声明为void。

不要将正常值和错误参数一起返回，最好是正常值用输出参数获取，错误参数用返回值得到。

赋值函数要声明为引用类型，以提高效率。

相加函数要声明为值传递类型，因为是引用类型的话，返回的是指向局部对象的变量，当函数执行完毕后该对象释放，得不到正确的值。

1.6.3 函数内部实现的规则

在函数的入口处对参数进行有效性检查，适当使用断言机制，当然断言机制只在调试中起作用，但是那会使我们更容易发现错误并加以改正。

在函数返回处进行返回值检查，如：

char* get(void)

{

    char szTmp[] = “hello world!”;

        return szTmp;

}

以下几个原则要特别注意：

²       return语句不可以返回指向栈内存的“指针”或者“引用”；

²       要弄清楚要返回的是值、指针还是引用；

²       如果返回的是对象，请考虑return语句的效率；

 

return string(s1+s2);

 

string strTmp;

strTmp = string(s1+s2);

return strTmp;

比较上面两段代码，右边的代码在执行时比左边的多了构造和析构两个过程，效率要低很多，尤其是该对象为一个很复杂的对象的时候。

尽量编写功能单一的函数；

函数体内的语句如果过长，考虑是否应将函数拆分；

不要使程序有记忆功能，相同的输入应该有相同的输出，除非有意为之。

1.6.4 引用与指针的区别

u      引用在被创建的同时必须被初始化；

u      所引用的对象一旦指定就不可再更改；

u      不能有NULL引用，即引用必须指向一个具体的对象；

u      对引用变量所作的一切改动，都会反映在该变量所引用的变量身上。

1.7 内存管理

1.7.1 内存分配方式

内存分配方式有三种：

1.        在静态存储区分配。内存在程序编译时就已经分配好，在整个程序存在期间一直存在，直到程序结束才被释放，如全局变量和static常量；

2.        在栈上分配内存。函数内部的变量在执行时会临时分配内存，当函数执行完毕自动释放所分配的内存；

3.        在堆上分配内存。用malloc和new申请的内存都是在堆上分配的内存，使用完毕要用free和delete手动释放内存。这种方式很灵活，但是问题也最多。

1.7.2 常见的内存错误

常见的内存错误有以下几种：

l        内存未分配成功，却使用了它；

l        内存分配成功，但是未被初始化；

l        内存分配成功且被初始化，但是使用时超过了所分配的界限；

l        分配了动态内存，但使用完毕未释放，造成内存泄漏；

l        释放了内存后却继续使用它；

响应的对策为：

l        使用malloc和new申请内存后立即用if (p == NULL)来做检查；

l        要养成对内存进行初始化的习惯，哪怕只是微不足道的小字符串；

l        对内存界限要特别注意循环过程中的多1或者少1的错误；

l        动态内存的申请必须与释放语句配对使用；

l        动态内存被释放后，要立即将其置为NULL，防止产生野指针，因为if (p == NULL)语句检查不出这类错误。

1.7.3 指针与数组

数组或者在静态存储区被创建（如全局数组），或者在栈上被创建，数组是占用一块内存区域，而不是指向一块内存区域，一旦被创建，就不能更改内存区域，只能更改存储内容。

指针可以指向随意大小的内存块，而且可以更换指向的区域，使用起来更加灵活。

指向常量的指针不能更改存储区内的内容；

数组不能用=语句进行赋值，但是指针可以，指针的=操作实际就是改变指针所指向的内存区，而不是真正意义上的复制；

数组内容的比较也不能用==，而只能用strcmp来进行；

用sizeof计算内存容量时，指针变量的大小都是4，而数组则是实际数组内存的大小。

1.7.4 利用指针参数传递内存

比较下面三段语句：

void GetMemory(char* p)

{

 

p = new char[10];

}

void GetMemory(char** p)

{

    p = (char*)(new char[10]);

 

}

char* GetMemory(void){

    char* p;

    p = new char[10];

    return p;

}

第一个函数是在栈上申请的内存，函数结束后被释放了，所以失败，第二个虽然也是，但是因为是指向指针的指针申请的，所以会成功，但是很难理解，第三个是用返回值申请的内存，而且是成功的。

char* GetMemory2(void)

{

    char szTmp[] = “hello world”;

    return szTmp; //指向了栈内存，最终使返回的指针所指向的区域内容为垃圾

}

char* GetMemory2(void)

{

    char* p = “hello world”;

    return p; //指向了常量内存，无论何时使用该函数申请内存都将得到一块常量内存区，不可更改内容

}

1.7.5 动态内存的释放

动态内存必须手动释放，内存被释放了，并不代表指向该内存的指针为NULL指针了，所以当未将释放的指针赋值为NULL时，利用if (p == NULL)检查不出问题来。

malloc和free不能处理非内部数据类型的情况，而且由于其实库函数而不是运算符，编译器不能控制它，导致很多问题检查不出来，而new和delete是运算符，编译器可以控制。

如果用new创建了对象数组，则在释放时必须写成delete []objects。

使用new创建对象数组时，只能使用不带参数的构造对象。

1.8 C++函数的高级特性

1.8.1 函数的重载

C++比C语言多了重载(overloaded)、内联(inline)、const和virtual四种机制。

如果C++要调用已经编译过了的C函数，要像下面这样写：

extern “C”

{

    void foo(int x, int y);

}

这个语句告诉编译器，要用的函数是标准的C函数。

函数重载的一个最主要特征就是函数名称相同，但是要注意的是，并不是所有重名的函数都构成了重载，重名的全局函数和类的成员函数就不是重载，类的函数被全局函数覆盖了，全局函数前面加::加以区别。

另外要注意的是要当心自动类型转换带来的语义二义性特征，如：

void func(int x);

void func(float x);

如果在以下情况中使用时：

func(0.5);

这种情况编译器无法区分具体调用哪个函数，所以要用以下形式调用：

func(float(0.5));

1.8.2 成员函数的重载，覆盖与隐藏

成员函数被重载的特征有：

1、在同一个类中

2、函数名字相同

3、参数不同

4、virtual关键字可有可无

5、  

成员函数被覆盖的特征：

1、不在同一个类中

2、函数名字相同

3、参数相同

4、virtual关键字必须有

5、  

成员函数被隐藏的特征有：

1、不在用一个类中

2、函数名字相同

3、参数不同

4、virtual关键字可有可无？

 

1.8.3 参数的缺省值

l        缺省值只能出现在函数的定义中，不能出现在函数的实现中

l        缺省参数只能从后往前挨个缺省，否则将会使函数在调用时不正确

1.8.4 运算符重载

l        重载的运算符必须是C++中原有的，但是不包括.

l        运算符重载虽然看起来怪模怪样，但是本质上和其他成员函数是一样的

Complex operator +(const Complex& a, const Complex& b);

1.8.5 内联函数

宏不能操作类的数据成员，C++中的内联机制完全取代了宏定义，而且增加了类型检查，还可以自如的操纵类的数据成员。

inline是一种用于实现的关键字，在声名函数时加inline关键字而在实现时不加不会使该函数成为内联函数，反之，在函数的实现代码前加inline关键字，则无论在声名函数时是否加inline关键字，函数都成为了内联函数。

另外，在类声名中直接写了实现代码的函数自动成为内联函数。

内联函数不要过分使用，当执行内联函数代码时的开销比调用函数的开销大，则用内联函数是不明智的。

当内联函数内有循环时，最好不要用使之成为内联函数。

类的构造和析构代码不要加在类的声名中。

1.9 类的构造、析构和赋值

1.9.1 构造函数的初始化表

构造函数初始化表的使用规则：

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

u      类中的const常量只能在初始化表里进行初始化

u      类的成员函数可以在初始化表里或者函数体内被赋值

1.9.2 构造和析构的次序

构造从类层次的根处开始，在每一层中，首先调用基类的构造函数，然后调用成员对象的构造函数。析构则严格按照与构造相反的次序执行，该次序是唯一的，否则编译器将无法自动执行析构过程。

对类成员变量的初始化顺序并不是按照初始化表进行的，而是按照变量的声明顺序来的。

典型的构造析构和赋值函数：

//不带参数的构造函数

String::String()

{

      m_Data = NULL;

}

 

//带参数的构造函数

String::String(const char* pStr)

{

      if ( psz == NULL )

      {

             m_data = new char[1];

             *m_data = '/0';

      }

      else

      {

             m_data = new char[strlen(pStr)+1];

             strcpy(m_data, pStr);

      }

}

 

String::~String()

{

      delete []m_data;

}

 

String& String::operator =(const String& str)

{

      if (this == &str) //防止自我复制

             return *this;

 

      if (m_data != NULL) //释放内存

      {

             delete []m_data;

             m_data = NULL;

      }

 

      m_data = new char[strlen(str.m_data)+1];

      strcpy(m_data, str.m_data);

 

      return *this;

}

1.10 类的继承与组合

1.10.1 继承

Ø        毫不相关的两个类不要生硬的继承

Ø        若在逻辑关系上B是A的一种，并且A的所有数据及行为对B都有意义，则此时B可以从A继承

1.10.2 组合

Ø        若在逻辑关系上，B是A的一部分，则不允许B从A继承，只能用B和其他的类组合成A

1.11 其他的一些经验

1.11.1 使用const关键字提高程序健壮性

Ø        使用const关键字修饰参数

const关键字不仅仅可以用来定义常量，跟主要的是被用来修饰参数和函数返回值，甚至是函数的定义体（查找一下例子）；

如果参数做输出用，无论该参数是引用参数还是指针参数，都不能用const修饰；

如果参数为输入参数，而且采用值传递，则无论用不用const，都不会使程序效率提高；

如果参数为输入参数，且采用引用传递，则为防止被引用的参数被以外改变，则加const修饰；

如以下函数：

void Func1(int num);

void Func1(const int& num);

这两个函数效率一样，因为int为内部数据类型，不存在构造，析构等过程，但假如函数为下面这样：

void Func1(A a);

void Func1(const A& a);

A为自定义的类，则后一个函数效率明显要高。

Ø        使用const修饰函数返回值

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

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

函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达。如：A & operate = (const A &other);

Ø        任何不会修改数据成员的函数都应该声明为const 类型。

如果在编写const 成员函数时，不慎修改了数据成员，或者调用了其它非const 成员函数，编译器将指出错误，这无疑会提高程序的健壮性。

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;

}

1.11.2 提高程序的效率

    以下是几条对提高程序效率有帮助的建议：

u       不要一味地追求程序的效率，应当在满足正确性、可靠性、健壮性、可读性等质量因素的前提下，设法提高程序的效率。

u       以提高程序的全局效率为主，提高局部效率为辅。

u       在优化程序的效率时，应当先找出限制效率的“瓶颈”，不要在无关紧要之处优化。

u       先优化数据结构和算法，再优化执行代码。

u       有时候时间效率和空间效率可能对立，此时应当分析那个更重要，作出适当的折衷。例如多花费一些内存来提高性能。

u      不要追求紧凑的代码，因为紧凑的代码并不能产生高效的机器码。