高质量软件设计指南-C++/C（第二版）摘要

 

第五章 C++/C程序设计入门<o:p></o:p>

C++标准对main函数有几个不同于一般函数的限制：

（1）不能重载；（2）不能内联；（3）不能定义为静态的；（4）不能取其地址；（5）不能由用户直接调用；

<o:p> </o:p>

int a ;      //在C中为声明，在C++为定义

<o:p> </o:p>

在C++/C中，全局变量（extern 或 static）存放在程序的静态数据区中，在程序进入main之前创建，在main结束之后销毁，因此我们的代码没有机会初始化它们。

<o:p> </o:p>

全局的声明和定义应放在源文件的开头位置。

<o:p> </o:p>

C++的访问控制策略是为了防止意外事件而不是为了防止对编译器的故意欺骗。<o:p></o:p>

class Base{

public:

       virtual Say() {std::cout<<”Base::Say() was invoked”<<std::endl;}

};

Class Derived:public Base{

private:

       virtual Say() {std::cout<<”Derived::Say() was invoked”<<std::endl;}

}

//测试

void test(void){

       Base *p = new Derived;

       p->Say();       //出乎意料的绑定到了一个private函数上！

<o:p> </o:p>

类型转换并不是改变原来的类型和值，而是生成了新的临时变元，其类型为目标类型。

<o:p> </o:p>

标准C允许非void 类型指针和void 类型指针互相转化，而标准C++只允许非void 指针转化为void 类型指针，反过来是需要强制转换。

<o:p> </o:p>

强制转换中的内存截断和内存扩张：<o:p></o:p>

double d = 1000.25;

int *pInt = (int*)&d;

int i = 100;

double *pDbl = (double*)&i;

<o:p> </o:p>

不要用前导“_”定义自己的标志符。

<o:p> </o:p>

基本数据类型的字面常量、枚举常量、sizeof()、常量表达式，不需要分配存储空间，编译时放到程序的符号表(不是ROM，不能取地址)中；而字符串常量、const常量（尤其是ADT/UDT的const对象）就要分配运行时存储空间。

<o:p> </o:p>

布尔变量与零值比较：if(flag) 或if(!flag)

整型变量与零值比较：if(0==value ) 或 if(0!=value)

浮点变量与零值比较：if(abs(x)<=EPSILON) 或 if(abs(x)>=EPSILON)

指针变量与零值比较：if(NULL==p) 或 if(NULL!=p)

<o:p> </o:p>

不要忘记switch的default ，即使不需要。

<o:p> </o:p>

如果循环体中出现了continue语句，要防止它跳过循环变量修改语句，因此最好把循环变量的修改放在前面。

<o:p> </o:p>

如果你的循环是确定的，用for；不确定，用while。

<o:p> </o:p>

for中计数器一律用“前闭后开法”。

<o:p> </o:p>

在多层嵌套的循环中，应尽可能把最长的循环放在最内层。

<o:p> </o:p>

如果循环体内存在逻辑判断，并且循环次数很大，宜将逻辑判断移到循环体的外面。

第六章 C++/C常量

事实上只存在基本数据类型的字面常量。

<o:p> </o:p>

在C中，const定义的常量是不能修改的变量，因此会给它分配空间(外连接的)；但C++中，对于基本类型常量放到符号表中，对于ADT/UDT的const对象则需要分配内存。还有一些，如强制声明的extern的符号常量或取符号常量的地址，会分配存储空间。

<o:p> </o:p>

const long lng = 10;            <o:p></o:p>

long *pl = (long*)&lng;         //去取常量地址<o:p></o:p>

*pl = 1000;                          //“迂回修改”<o:p></o:p>

cout << *pl << endl;             //1000,修改拷贝<o:p></o:p>

cout << lng << endl;             //10，原始常量并没有修改<o:p></o:p>

<o:p> </o:p>

对于构造类型的const 对象，它成了编译时不允许修改的变量，但可以绕过。<o:p></o:p>

Class Integer<o:p></o:p>

{<o:p></o:p>

       Public:<o:p></o:p>

              Long m_lng;<o:p></o:p>

};<o:p></o:p>

const Integer int_1;<o:p></o:p>

int_1.m_lng = 0;<o:p></o:p>

Integer *pInt = (Integer*)&int_1;  //去除常熟性<o:p></o:p>

pInt->m_lng = 1000;<o:p></o:p>

cout << pInt->m_lng << endl;      //1000,修改const对象<o:p></o:p>

cout << int_1.m_lng << endl;              、//1000，“迂回修改” 成功!<o:p></o:p>

<o:p> </o:p>

理论上，只要能得到对象的地址，你就可以设法绕过编译器随意修改它，除非有操作系统的保护。<o:p></o:p>

<o:p> </o:p>

在C中，const符号常量默认是外连接的，也就是说不能在两个以上的源文件中定义一个同名的const符号常量，或这把一个const符号常量放在头文件中而在多个源文件爱您中包含该头文件。而C++中const默认是内连接的，每个编译单元编译时会分别为它们分配内存，在连接时进行常量折叠。<o:p></o:p>

<o:p> </o:p>

（1）       const常量有数据类型，而宏常量没有，因此没有类型检查。<o:p></o:p>

（2）       有些调试工具可以对const常量进行调试。<o:p></o:p>

因此C++中应尽量用const 而不用#define。<o:p></o:p>

<o:p> </o:p>

非静态const数据成员是属于每一个对象的成员，只在某个对象的生存期内常量，而对于整个类是可变的，除非是static const。因此不能在类声明中初始化非静态const数据成员，只能在构造函数的初始化列表中初始化。<o:p></o:p>

<o:p> </o:p>

如何建立在整个类中都恒定的类常量？<o:p></o:p>

（1）用枚举常量；（2）static const。<o:p></o:p>

class A{<o:p></o:p>

       enume<o:p></o:p>

       {<o:p></o:p>

              SIZE1 = 100,SIZE2 = 200<o:p></o:p>

};<o:p></o:p>

int array1[SIZE1];<o:p></o:p>

int array2[SIZE2]; <o:p></o:p>

};<o:p></o:p>

第七章 函数设计基础<o:p></o:p>

连接的本质就是把一个名字的实现绑定到对它的每一个引用上。<o:p></o:p>

<o:p> </o:p>

如果函数没有参数，那么使用void 而不要空着。因为标准C把空参数列表解释为可以接受任何类型和任意个数的参数，而C++解释为不接受任何实参。<o:p></o:p>

<o:p> </o:p>

一般，输出参数放在前面，输入参数放在后面。<o:p></o:p>

<o:p> </o:p>

不要忽略返回类型。C认为会返回int。<o:p></o:p>

<o:p> </o:p>

为了避免误解，应当将正常值和错误标志分开，即正常值用输出参数获得，而错误标志用return 语句返回。如将标准C中的int getchar()改为bool GetChar(char*)就好多了。<o:p></o:p>

<o:p> </o:p>

尽管语法允许，但请不要在内层程序块中覆盖外层程序块的名字，否则会损害程序的可理解性。<o:p></o:p>

<o:p> </o:p>

非静态全局函数和全局变量，名字空间的成员是外连接的。<o:p></o:p>

<o:p> </o:p>

在函数的入口处，建议用断言来检测参数的有效性。<o:p></o:p>

<o:p> </o:p>

Use const whenever you need.<o:p></o:p>

<o:p> </o:p>

第八章 函数和指针<o:p></o:p>

int* a,b,c;              会理解为int *a,b,c，因此不要用这种声明方式。<o:p></o:p>

<o:p> </o:p>

向函数传递多维数组，不需要说明第一维大小而必须说明其它各维大小。<o:p></o:p>

<o:p> </o:p>

任何成员函数都是独立于类的对象而存在的，所以能够取到一个成员函数的地址。<o:p></o:p>

<o:p> </o:p>

为了与静态成员函数区别，取virtual 函数和普通成员函数的地址必须要使用&运算符，但取静态成员函数地址不必要。<o:p></o:p>

<o:p> </o:p>

构造类型虽然可以嵌套定义，但其嵌套递定义的类型对象不一定就存在包含关系，存在包含关系的对象类型也不一定是嵌套定义的。当一个类型A只会在另一个类型B中被使用时，就可以把A定义在B 的定义体内，这样可以减少暴露在外面的用户自定义类型的个数。<o:p></o:p>

<o:p> </o:p>

第九章 高级数据类型<o:p></o:p>

默认的拷贝赋值函数就是对象的位拷贝语义，但不能直接比较大小。<o:p></o:p>

<o:p> </o:p>

位域<o:p></o:p>

不要定义超过类型最大维数的位域成员。、<o:p></o:p>

可以定义匿名的位域成员，其语义是占位符。<o:p></o:p>

可以定义长度为0 的位域成员，其作用是迫使下一个成员从下一个完整的机器字开始分配空间。<o:p></o:p>

不要让一个位域成员跨字节，这样会增加计算开销。<o:p></o:p>

<o:p> </o:p>

union<o:p></o:p>

使用一个成员存入而用另一个成员取出是可以的，但可能不是你想要的。<o:p></o:p>

在定义联合变量时可以指定初值，但是只能指定一个初始值，且该初始值必须与联合的第一个成员的类型匹配。你可以取联合的地址，也可以取其成员的地址，它们都是联合的地址。你可以在同类型联合之间赋值，但你不能比较两个联合变量的大小，不光是因为肯能的填补字节，而且这两个变量可能存储着不同类型的成员，此时它们代表这两个不同类型的变量。<o:p></o:p>

<o:p> </o:p>

C++对联合进行了扩充，除了数据成员还可以定义成员的访问说明符，可以定义成员函数，甚至可以定义构造函数和析构函数；但联合不能包含虚函数和静态数据成员，不能作为基类。C++还支持匿名联合。<o:p></o:p>

<o:p> </o:p>

匿名的枚举类型就相当于直接定义的const符号常量。<o:p></o:p>

<o:p> </o:p>

第十章 C++/C 编译预处理<o:p></o:p>

（1）带参数的宏体和各个参数都应用括号括起来。<o:p></o:p>

（2）不要在引用宏定义的参数列表用++和--。<o:p></o:p>

（3）带参数的宏定义不是函数，因此没有函数调用的开销，但是每一处宏扩展会生成重复代码，会使代码体积增大。<o:p></o:p>

<o:p> </o:p>

给宏添加注释用/*…*/，不要用//，因为有些编译器会把宏后面的行注释理解为宏的以部分。<o:p></o:p>

<o:p> </o:p>

宏名用大写字母并在各个单词中间用“_”隔开。<o:p></o:p>

<o:p> </o:p>

如果要公布某个宏，那么宏定义应放在头文件中，否则放在源文件顶部。<o:p></o:p>

<o:p> </o:p>

不要使用宏来定义新类型名，应使用typedef。<o:p></o:p>

# 构串操作符，##合并操作符。<o:p></o:p>

<o:p> </o:p>

第十一章 C++/C文件结构和程序版式<o:p></o:p>

ADT/UDT版式：<o:p></o:p>

先public 后private。<o:p></o:p>

<o:p> </o:p>

第十二章 C++/C应用程序命名规则<o:p></o:p>

类名、函数名首字母应大写，变量名、参数名首字母应小写。<o:p></o:p>

静态变量以s_开头，全局变量以g_开头，成员变量以m_开头。<o:p></o:p>

<o:p> </o:p>

第十三章 C++/C面向对象程序设计方法概述<o:p></o:p>

编写拷贝赋值函数的原则：<o:p></o:p>

(1)    一定要检查自赋值，地址相等时才认为是同一个对象；<o:p></o:p>

(2)    返回本对象引用，用return *this。<o:p></o:p>

如：<o:p></o:p>

String& String::operator=(const String& other){<o:p></o:p>

       //检查自赋值<o:p></o:p>

       if(this != other){<o:p></o:p>

              //释放原有的内存资源<o:p></o:p>

              delete[] m_data;<o:p></o:p>

              //分配新的内存资源，并复制内容<o:p></o:p>

              int len = strlen(other.m_data);<o:p></o:p>

              m_data = new char[len + 1];<o:p></o:p>

strcpy(m_data,other.m_data);<o:p></o:p>

m_size = len;<o:p></o:p>

}<o:p></o:p>

       //返回本对象的引用<o:p></o:p>

       return *this;<o:p></o:p>

}<o:p></o:p>

如果不想编写，也不想让别人调用，可将拷贝构造函数和拷贝赋值函数声明为private。<o:p></o:p>

<o:p> </o:p>

如何实现派生类的基本函数：<o:p></o:p>

(1)    派生类的构造函数应在其初始化列表里显式地调用基类的构造函数；<o:p></o:p>

(2)    如果基类是多态类，那么必须把基类的析构函数定义为虚函数。<o:p></o:p>

如：<o:p></o:p>

#include <iostream><o:p></o:p>

class Base{<o:p></o:p>

public:<o:p></o:p>

       virtual ~Base() {std::cout<<”Base::~Base()”<<std::endl;}<o:p></o:p>

};<o:p></o:p>

class Derived{<o:p></o:p>

public:<o:p></o:p>

       virtual ~Derived() { delete p_test;std::cout<<”Derived::~Derived()”<<std::endl;}<o:p></o:p>

private:<o:p></o:p>

       char *p_test;<o:p></o:p>

};<o:p></o:p>

int main(void){<o:p></o:p>

       Base *pB = new Derived;<o:p></o:p>

       Delete pB;<o:p></o:p>

       return(0);<o:p></o:p>

}<o:p></o:p>

<o:p>&

评论

3 楼 wdx04 2007-09-03  

非常恶心的书，非常恶心的作者

2 楼 soulmachine 2007-04-05  

这本书不是外国人写的，是国内的林锐博士写的，非常好，国外有一本类似的书：《C++ Coding Standards》，不过没有林锐的详细，站的高度也高些

1 楼 bigpanda 2007-04-04  

这本书原版是英文么？英文名叫什么？