日志

高质量C/C++编程读书笔记<第一部分,共2部分>

已有 1042 次阅读| 2007-9-12 09:03

天气: 晴朗

心情: 高兴

1、空行不会浪费内存
    在每个类声明之后、每个函数定义结束之后都要加空行。
    在一个函数体内，逻揖上密切相关的语句之间不加空行，其它地方应加空行分隔。

2、一行代码只做一件事情
    如只定义一个变量，或只写一条语句。这样的代码容易阅读，并且方便于写注释。
    if、for、while、do等语句自占一行，执行语句不得紧跟其后。不论执行语句有多少都要加{}。这样可以防止书写失误。

3、尽可能在定义变量的同时初始化该变量
    定义变量和引用变量之处尽可能离的近点

4、关键字之后要留空格，函数名之后不要留空格
    象const、virtual、inline、case 等关键字之后至少要留一个空格
    一元操作符如“!”、“~”、“++”、“--”、“&”（地址运算符）等前后不加空格
    象“［］”、“.”、“->”这类操作符前后不加空格。
    二元操作符的前后应当加空格。如“=”、“+=” “>=”、“<=”、“+”、“*”、“%”、“&&”、“||”、“<<”,“^”

5、程序的分界符‘{’和‘}’应独占一行并且位于同一列，同时与引用它们的语句左对齐。

6、代码行最大宽度宜控制在70至80个字符以内。
    长表达式要在低优先级操作符处拆分成新行，操作符放在新行之首（以便突出操作符）。拆分出的新行要进行适当的缩进，使排版整齐。

7、应当将修饰符*和&紧靠变量名。

8、注释的花样要少
    边写代码边注释，修改代码同时修改相应的注释；
    当代码比较长，特别是有多重嵌套时，应当在一些嵌套的段落的结束处加注释，便于阅读。

9、类的版式主要有两种方式：
    （1）将private类型的数据写在前面，而将public类型的函数写在后面，采用这种版式的程序员主张类的设计“以数据为中心”，重点关注类的内部结构。
    （2）将public类型的函数写在前面，而将private类型的数据写在后面，采用这种版式的程序员主张类的设计“以行为为中心”，重点关注的是类应该提供什么样的接口（或服务）。
    建议采用“以行为为中心”的书写方式，即首先考虑类应该提供什么样的函数。这是很多人的经验——“这样做不仅让自己在设计类时思路清晰，而且方便别人阅读。因为用户最关心的是接口，谁愿意先看到一堆私有数据成员！”

10、命名规则
    命名规则尽量与所采用的操作系统或开发工具的风格保持一致。例如Windows应用程序的标识符通常采用“大小写”混排的方式，如AddChild。而Unix应用程序的标识符通常采用“小写加下划线”的方式，如add_child。
    程序中不要出现仅靠大小写区分的相似的标识符。
    程序中不要出现标识符完全相同的局部变量和全局变量。
    变量的名字应当使用“名词”或者“形容词＋名词”。
       如：    float value;
             float newValue;
    全局函数的名字应当使用“动词”或者“动词＋名词”（动宾词组）。类的成员函数应当只使用“动词”，被省略掉的名词就是对象本身。
       如：    DrawBox(); //全局函数
             box->Draw();   //类的成员函数
    用正确的反义词组命名具有互斥意义的变量或相反动作的函数等。
    尽量避免名字中出现数字编号，如Value1,Value2等，除非逻辑上的确需要编号。这是为了防止程序员偷懒，不肯为命名动脑筋而导致产生无意义的名字（因为用数字编号最省事）。
    常量全用大写的字母，用下划线分割单词。
    静态变量加前缀s_（表示static）。如：static int s_initValue;   // 静态变量
    如果不得已需要全局变量，则使全局变量加前缀g_（表示global）。如：int g_howManyPeople;   //全局变量
    类的数据成员加前缀m_（表示member），这样可以避免数据成员与成员函数的参数同名。
    为了防止某一软件库中的一些标识符和其它软件库中的冲突，可以为各种标识符加上能反映软件性质的前缀。例如三维图形标准OpenGL的所有库函数均以gl开头，所有常量（或宏定义）均以GL开头。

11、运算符

优先级	运算符	结合律
<!--[if !supportEmptyParas]--> <!--[endif]--> <!--[if !supportEmptyParas]--> <!--[endif]--> 从 <!--[if !supportEmptyParas]--> <!--[endif]--> 高 <!--[if !supportEmptyParas]--> <!--[endif]--> 到 <!--[if !supportEmptyParas]--> <!--[endif]--> 低 <!--[if !supportEmptyParas]--> <!--[endif]--> 排 <!--[if !supportEmptyParas]--> <!--[endif]--> 列	( ) [ ] -> .	从左至右
	! ~ ++ -- （类型） sizeof + - * &	从右至左 <!--[if !supportEmptyParas]--> <!--[endif]-->
	* / %	从左至右
	+ -	从左至右
	<< >>	从左至右
	< <= > >=	从左至右
	== !=	从左至右
	&	从左至右
	^	从左至右
	\|	从左至右
	&&	从左至右
	\|\|	从右至左
	?:	从右至左
	= += -= *= /= %= &= ^= \|= <<= >>=	从左至右

    如果代码行中的运算符比较多，用括号确定表达式的操作顺序，避免使用默认的优先级。
    不要编写太复杂的复合表达式。
    不要有多用途的复合表达式。
    不要把程序中的复合表达式与“真正的数学表达式”混淆。
        如：if (a < b < c)            // a < b < c是数学表达式而不是程序表达式
            并不表示if ((a<b) && (b<c))
            而是成了令人费解的if ( (a<b)<c )

    （1）不可将布尔变量直接与TRUE、FALSE或者1、0进行比较。
    假设布尔变量名字为flag，它与零值比较的标准if语句如下：
        if (flag)    // 表示flag为真
        if (!flag)    // 表示flag为假
    其它的用法都属于不良风格，例如：if (flag == TRUE) 或者 if (flag == 1 )
    （2）应当将整型变量用“==”或“!=”直接与0比较。
    假设整型变量的名字为value，它与零值比较的标准if语句如下：
       if (value == 0)
       if (value != 0)
    不可模仿布尔变量的风格而写成
       if (value)    // 会让人误解 value是布尔变量
       if (!value)
    （3）不可将浮点变量用“==”或“!=”与任何数字比较。
    千万要留意，无论是float还是double类型的变量，都有精度限制。所以一定要避免将浮点变量用“==”或“!=”与数字比较，应该设法转化成“>=”或“<=”形式。
    假设浮点变量的名字为x，应当将
       if (x == 0.0)     // 隐含错误的比较
    转化为
       if ((x>=-EPSINON) && (x<=EPSINON))
    其中EPSINON是允许的误差（即精度）。
    （4）应当将指针变量用“==”或“!=”与NULL比较。
    指针变量的零值是“空”（记为NULL）。尽管NULL的值与0相同，但是两者意义不同。假设指针变量的名字为p，它与零值比较的标准if语句如下：
        if (p == NULL)    // p与NULL显式比较，强调p是指针变量
        if (p != NULL)
不要写成
        if (p == 0)   // 容易让人误解p是整型变量
        if (p != 0)
    或者
        if (p)        // 容易让人误解p是布尔变量
        if (!p)

    有时候我们可能会看到 if (NULL == p) 这样古怪的格式。不是程序写错了，是程序员为了防止将 if (p == NULL) 误写成 if (p = NULL)，而有意把p和NULL颠倒。编译器认为 if (p = NULL) 是合法的，但是会指出 if (NULL = p)是错误的，因为NULL不能被赋值。
    （5）其他
    程序中有时会遇到if/else/return的组合，应该将如下不良风格的程序
    if (condition)
        return x;
    return y;
改写为
    if (condition)
    {
        return x;
    }
    else
    {
        return y;
    }
或者改写成更加简练的
    return (condition ? x : y);

12、循环语句的效率
    C++/C循环语句中，for语句使用频率最高，while语句其次，do语句很少用。提高循环体效率的基本办法是降低循环体的复杂性。
    在多重循环中，如果有可能，应当将最长的循环放在最内层，最短的循环放在最外层，以减少cpu跨切循环层的次数。
    如果循环体内存在逻辑判断，并且循环次数很大，宜将逻辑判断移到循环体的外面。示例左图的程序比示例右图多执行了N-1次逻辑判断。并且由于前者老要进行逻辑判断，打断了循环“流水线”作业，使得编译器不能对循环进行优化处理，降低了效率。如果N非常大，最好采用示例右图的写法，可以提高效率。如果N非常小，两者效率差别并不明显，采用示例左图的写法比较好，因为程序更加简洁。

for (i=0; i<N; i++)
{

if (condition)

DoSomething();

else

DoOtherthing();

}

if (condition)

{

for (i=0; i<N; i++)

DoSomething();

}

else

{

for (i=0; i<N; i++)

DoOtherthing();

}

效率低但程序简洁                            效率高但程序不简洁

    不可在for 循环体内修改循环变量，防止for 循环失去控制。
    推荐for使用时for (int x=0; x<N; x++)这种写法，不推荐for (int x=0; x<=N-1; x++)，虽然循环次数一样
    switch语句中，每个case语句的结尾不要忘了加break，否则将导致多个分支重叠（除非有意使多个分支重叠）。不要忘记最后那个default分支。即使程序真的不需要default处理，也应该保留语句
        default : break;
    这样做并非多此一举，而是为了防止别人误以为你忘了default处理。

13、goto语句
    自从提倡结构化设计以来，goto就成了有争议的语句。首先，由于goto语句可以灵活跳转，如果不加限制，它的确会破坏结构化设计风格。其次，goto语句经常带来错误或隐患。它可能跳过了某些对象的构造、变量的初始化、重要的计算等语句。如果编译器不能发觉此类错误，每用一次goto语句都可能留下隐患。
    担goto语句至少有一处可显神通，它能从多重循环体中咻地一下子跳到外面，用不着写很多次的break语
句;

14、在C++ 程序中只使用const常量而不使用宏常量，即const常量完全取代宏常量。
    尽量使用含义直观的常量来表示那些将在程序中多次出现的数字或字符串。
    C++ 语言可以用const来定义常量，也可以用 #define来定义常量（宏常量）。但是前者比后者有更多的优点：
    （1） const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误（边际效应）。
    （2） 有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。
    需要对外公开的常量放在头文件中，不需要对外公开的常量放在定义文件的头部。为便于管理，可以把不同模块的常量集中存放在一个公共的头文件中。
    如果某一常量与其它常量密切相关，应在定义中包含这种关系，而不应给出一些孤立的值。
        const float   RADIUS = 100;
       const float   DIAMETER = RADIUS * 2;

15、类中的常量
    有时我们希望某些常量只在类中有效。由于#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）。

16、函数设计
    函数接口的两个要素是参数和返回值。C语言中，函数的参数和返回值的传递方式有两种：值传递（pass by value）和指针传递（pass by pointer）。C++ 语言中多了引用传递（pass by reference）。
    参数的书写要完整，不要贪图省事只写参数的类型而省略参数名字。如果函数没有参数，则用void填充。

       void SetValue(int width, int height);   // 良好的风格
       void SetValue(int, int);            // 不良的风格
       float GetValue(void);    // 良好的风格
       float GetValue();       // 不良的风格

    参数命名要恰当，顺序要合理
       void StringCopy(char *str1, char *str2);
    我们很难搞清楚究竟是把str1拷贝到str2中，还是刚好倒过来。
       void StringCopy(char *strSource, char *strDestination);

    如果参数是指针，且仅作输入用，则应在类型前加const，以防止该指针在函数体内被意外修改。
    如：void StringCopy(char *strDestination，const char *strSource);

    如果输入参数以值传递的方式传递对象，则宜改用“const &”方式来传递，这样可以省去临时对象的构造和析构过程，从而提高效率。
    避免函数有太多的参数，参数个数尽量控制在5个以内。
    尽量不要使用类型和数目不确定的参数。C标准库函数printf是采用不确定参数的典型代表，其原型为：
       int printf(const chat *format[, argument]…);
    这种风格的函数在编译时丧失了严格的类型安全检查。
    不要省略返回值的类型。C语言中，凡不加类型说明的函数，一律自动按整型处理。这样做不会有什么好处，却容易被误解为void类型。如果函数没有返回值，那么应声明为void类型。

    函数名字与返回值类型在语义上不可冲突。
        违反这条规则的典型代表是C标准库函数getchar。
    例如：
    char c;
    c = getchar();
    if (c == EOF)
    …
    按照getchar名字的意思，将变量c声明为char类型是很自然的事情。但不幸的是getchar的确不是char类型，而是int类型，其原型如下：
        int getchar(void);
    由于c是char类型，取值范围是[-128，127]，如果宏EOF的值在char的取值范围之外，那么if语句将总是失败，这种“危险”人们一般哪里料得到！导致本例错误的责任并不在用户，是函数getchar误导了使用者。

    不要将正常值和错误标志混在一起返回。正常值用输出参数获得，而错误标志用return语句返回。
    回顾上例，C标准库函数的设计者为什么要将getchar声明为令人迷糊的int类型呢？他会那么傻吗？
    在正常情况下，getchar的确返回单个字符。但如果getchar碰到文件结束标志或发生读错误，它必须返回一个标志EOF。为了区别于正常的字符，只好将EOF定义为负数（通常为负1）。因此函数getchar就成了int类型。
    我们在实际工作中，经常会碰到上述令人为难的问题。为了避免出现误解，我们应该将正常值和错误标志分开。即：正常值用输出参数获得，而错误标志用return语句返回。
    函数getchar可以改写成 BOOL GetChar(char *c);
    虽然gechar比GetChar灵活，例如 putchar(getchar()); 但是如果getchar用错了，它的灵活性又有什么用呢？

    有时候函数原本不需要返回值，但为了增加灵活性如支持链式表达，可以附加返回值。
    例如字符串拷贝函数strcpy的原型：
    char *strcpy(char *strDest，const char *strSrc);
    strcpy函数将strSrc拷贝至输出参数strDest中，同时函数的返回值又是strDest。这样做并非多此一举，可以获得如下灵活性：
    char str[20];
    int length = strlen( strcpy(str, “Hello World”) );

    如果函数的返回值是一个对象，有些场合用“引用传递”替换“值传递”可以提高效率。而有些场合只能用“值传递”而不能用“引用传递”，否则会出错。
        例如：
    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什么也得不到，留下了隐患。

17、不同功能的函数其内部实现各不相同，看起来似乎无法就“内部实现”达成一致的观点。但根据经验，我们可以在函数体的“入口处”和“出口处”从严把关，从而提高函数的质量。
    在函数体的“入口处”，对参数的有效性进行检查。很多程序错误是由非法参数引起的，我们应该充分理解并正确使用“断言”（assert）来防止此类错误。
    在函数体的“出口处”，对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的变量不存在构造函数与析构函数，虽然该“临时变量的语法”不会提高多少效率，但是程序更加简洁易读。

    函数的功能要单一，不要设计多用途的函数。
    函数体的规模要小，尽量控制在50行代码之内。
    尽量避免函数带有“记忆”功能。相同的输入应当产生相同的输出。带有“记忆”功能的函数，其行为可能是不可预测的，因为它的行为可能取决于某种“记忆状态”。这样的函数既不易理解又不利于测试和维护。在C/C++语言中，函数的static局部变量是函数的“记忆”存储器。建议尽量少用static局部变量，除非必需。
    不仅要检查输入参数的有效性，还要检查通过其它途径进入函数体内的变量的有效性，例如全局变量、文件句柄等。
    用于出错处理的返回值一定要清楚，让使用者不容易忽视或误解错误情况。

18、使用断言
    程序一般分为Debug版本和Release版本，Debug版本用于内部调试，Release版本发行给用户使用。
    断言assert是仅在Debug版本起作用的宏，它用于检查“不应该”发生的情况。示例6-5是一个内存复制函数。在运行过程中，如果assert的参数为假，那么程序就会中止（一般地还会出现提示对话，说明在什么地方引发了assert）。如复制不重叠的内存块：
    void *memcpy(void *pvTo, const void *pvFrom, size_t size)
    {
        assert((pvTo != NULL) && (pvFrom != NULL));     // 使用断言
        byte *pbTo = (byte *) pvTo;     // 防止改变pvTo的地址
        byte *pbFrom = (byte *) pvFrom; // 防止改变pvFrom的地址
        while(size -- > 0 )
            *pbTo ++ = *pbFrom ++ ;
        return pvTo;
    }
    assert不是一个仓促拼凑起来的宏。为了不在程序的Debug版本和Release版本引起差别，assert不应该产生任何副作用。所以assert不是函数，而是宏。程序员可以把assert看成一个在任何系统状态下都可以安全使用的无害测试手段。如果程序在assert处终止了，并不是说含有该assert的函数有错误，而是调用者出了差错，assert可以帮助我们找到发生错误的原因。