《C++编程思维》(Thinking in C++)部分精华提取
1、声明与定义：
首先，必须知道“声明”和“定义”之间的区别，因为这两个术语在全书中会被确切地使用。“声明”向计算机介绍名字，它说，“这个名字是什么意思”。而“定义”为这个名字分配
存储空间。无论涉及到变量时还是函数时含义都一样。无论在哪种情况下，编译器都在“定义”处分配存储空间。对于变量，编译器确定这个变量占多少存储单元，并在内存中产生存放它们的空间。对于函数，编译器产生代码，并为之分配存储空间。函数的存储空间中有一个由使用不带参数表或带地址操作符的函数名产生的指针。定义也可以是声明。如果该编译器还没有看到过名字A，程序员定义int A，则编译器马上为这个名字分配存储地址。声明常常使用于e x t e r n关键字。如果我们只是声明变量而不是定义它，则要求使用e x t e r n。对于函数声明， e x t e r n是可选的，不带函数体的函数名连同参数表或返回值，自动地作为一个声明。函数原型包括关于参数类型和返回值的全部信息。int f(float,char);是一个函数原型，因为它不仅介绍f这个函数的名字，而且告诉编译器这个函数有什么样的参数和返回值，使得编译器能对参数和返回值做适当的处理。C + +要求必须写出函数原型，因为它增加了一个重要的安全层。
extern int i;//声明
extern float f(float);//声明
float b;//声明+定义
float f(float a){//定义
return a+1.0;
}
int i;//定义
int h(int x){//声明+定义
return x+1;
}
main(){
b=1.0;
i=2;
f(b);
h(i);
}
在函数声明时，参数名可给出也可不给出。而在定义时，它们是必需的。这在C语言中确实如此，但在C + +中并不一定。
2、句柄类：
C + +中的存取控制允许将实现与接口部分分开，但实现的隐藏是不完全的。编译器必须知道一个对象的所有部分的声明，以便创建和管理它。我们可以想象一种只需声明一个对象的公共接口部分的编程语言，而将私有的实现部分隐藏起来。但C + +在编译期间要尽可能多地做静态类型检查。这意味着尽早捕获错误，也意味着程序具有更高的效率。然而这对私有的实现部分来说带来两个影响：一是即使程序员不能轻易地访问实现部分，但他可以看到它；二是造成一些不必要的重复编译。
可见的实现部分：
有些项目不可让最终用户看到其实现部分。例如可能在一个库的头文件中显示一些策略信息，但公司不想让这些信息被竞争对手获得。比如从事一个安全性很重要的系统(如加密算法)，我们不想在文件中暴露任何线索，以防有人破译我们的代码。或许我们把库放在了一个“有敌意”的环境中，在那里程序员会不顾一切地用指针和类型转换存取我们的私有成员。在所有这些情况下，就有必要把一个编译好的实际结构放在实现文件中，而不是让其暴露在头文件中。
减少重复编译：
在我们的编程环境中，当一个文件被修改，或它所依赖的文件包含的头文件被修改时，项目负责人需要重复编译这些文件。这意味着无论何时程序员修改了一个类，无论是修改公共的接口部分，还是私有的实现部分，他都得再次编译包含头文件的所有文件。对于一个大的项目而言，在开发初期这可能非常难以处理，因为实现部分可能需要经常改动；如果这个项目非常大，用于编译的时间过多就可能妨碍项目的完成。解决这个问题的技术有时叫句柄类（ handle classes）或叫“Cheshire Cat”[ 1 ]。有关实现的任何东西都消失了，只剩一个单一的指针“
s m i l e”。该指针指向一个结构，该结构的定义与其所有的成员函数的定义一样出现在实现文件中。这样，只要接口部分不改变，头文件就不需变
动。而实现部分可以按需要任意更动，完成后只要对实现文件进行重新编译，然后再连接到项目中。这里有个说明这一技术的简单例子。头文件中只包含公共的接口和一个简单的没有完全指定的类指针。这是所有客户程序员都能看到的。这行
struct cheshire;
是一个没有完全指定的类型说明或类声明（一个类的定义包含类的主体）。它告诉编译器，cheshire 是一个结构的名字，但没有提供有关该结构的任何东西。这对产生一个指向结构的指针来说已经足够了。但我们在提供一个结构的主体部分之前不能创建一个对象。在这种技术里，包含具体实现的结构主体被隐藏在实现文件中。
#ifndef HANDLE_H
#define HANDLE_H
class handle{
struct cheshire;
cheshire *smile;
public:
void initialize();
void cleanup();
int read();
void change(int);
};
#endif
这是所有客户程序员都能看到的。这行
struct cheshire;
是一个没有完全指定的类型说明或类声明（一个类的定义包含类的主体）。它告诉编译器，cheshire 是一个结构的名字，但没有提供有关该结构的任何东西。这对产生一个指向结构的指针来说已经足够了。但我们在提供一个结构的主体部分之前不能创建一个对象。在这种技术里，包含具体实现的结构主体被隐藏在实现文件中。
#include "handle.h"
struct handle::cheshire{
int i;
};
void handle::initialize(){
smile=(cheshire *)malloc(sizeof(cheshire));
assert(smile);
smile->i=0;
}
void handle::cheanup(){
free(smile);
}
int handle::read(){
return smile->i;
}
void handle::change(int x){
smile->i=x;
}
cheshire 是一个嵌套结构，所以它必须用范围分解符定义
struct handle::cheshire {
在h a n d l e : : i n i t i a l i z e ( )中，为cheshire struct分配存储空间[ 1 ]，在h a n d l e : : c l e a n u p ( )中这些空间被释放。这些内存被用来代替类的所有私有部分。当编译H A N D L E . C P P时，这个结构的定义被隐藏在目标文件中，没有人能看到它。如果改变了c h e s h i r e的组成，唯一要重新编译的是H A N D L E . C P P，因为头文件并没有改动。句柄（h a n d l
e）的使用就像任何类的使用一样，包含头文件、创建对象、发送信息。
#include "handle.h"
main(){
handle u;
u.initialize();
u.read();
u.change(2);
}
客户程序员唯一能存取的就是公共的接口部分，因此，只是修改了在实现中的部分，这些文件就不须重新编译。虽然这并不是完美的信息隐藏，但毕竟是一大进步
3、重载：
返回值重载：
void f();
int f();
当编译器能从上下文中唯一确定函数的意思时，如int x = f();这当然没有问题。然而，在C中，我们总是可以调用一个函数但忽略它的返回值，在这种情况下，编译器如何知道调用哪个函数呢？更糟的是，读者怎么知道哪个函数会被调用呢？仅仅靠返回值来重载函数实在过于微妙了，所以在C + +中禁止这样做。
4、const ：
与使用# d e f i n e一样，使用c o n s t必须把c o n s t定义放进头文件里。这样，通过包含头文件，可把c o n s t定义单独放在一个地方并把它分配给一个编译单元。C + +中的c o n s t默认为内部连接，也就是说，c o n s t仅在c o n s t被定义过的文件里才是可见的，而在连接时不能被其他编译单元看到。当定义一个常量（c o n s t）时，必须赋一个值给它，除非用e x t e r n作了清楚的说明：
extern const bufsize；
虽然上面的e x t e r n强制进行了存储空间分配（另外还有一些情况，如取一个c o n s t的地址，也要进行存储空间分配），但是C + +编译器通常并不为c o n s t分配存储空间，相反它把这个定义保存在它的符号表里。当c o n s t被使用时，它在编译时会进行常量折叠。
5、volatile：
v o l a t i l e的语法与c o n s t是一样的，但是v o l a t i l e的意思是“在编译器认识的范围外，这个数据可以被改变”。不知何故，环境正在改变数据（可能通过多任务处理），所以，v o l a t i l e告诉编译器不要擅自做出有关数据的任何假定—在优化期间这是特别重要的。如果编译器说：“我已经把数据读进寄存器，而且再没有与寄存器接触”。一般情况下，它不需要再读这个数据。但是，如果数据是v o l a t i l e修饰的，编译器不能作出这样的假定，因为可能被其他进程改变了，它必须重读这个数据而不是优化这个代码。就像建立c
o n s t对象一样，程序员也可以建立v o l a t i l e对象，甚至还可以建立const volatile对象，这个对象不能被程序员改变，但可通过外面的工具改变。下面是一个例子，它代表一个类，这个类涉及到硬件通信：
就像c o n s t一样，我们可以对数据成员、成员函数和对象本身使用v o l a t i l e，可以并且也只能为v o l a t i l e对象调用v o l a t i l e成员函数。函数i s r ( )不能像中断服务程序那样使用的原因是：在一个成员函数里，当前对象（ t h i s）的地址必须被秘密地传递，而中断服务程序I S R一般根本不要参数。为解决这个问题，可以使i s r ( )成为静态成员函数，这是下面章节讨论的主题。v o l a t i l e的语法与c o n s t是一样的，所以经常把它们俩放在一起讨论。为表示可以选择两个中的任何一个，它们俩通称为c
- v限定词。
6、内联函数（inline）：
在解决C + +中宏存取私有的类成员的问题过程中，所有和预处理器宏有关的问题也随着消失了。这是通过使宏被编译器控制来实现的。在C + +中，宏的概念是作为内联函数来实现的，而内联函数无论在任何意义上都是真正的函数。唯一不同之处是内联函数在适当时像宏一样展开，所以函数调用的开销被取消。因此，应该永远不使用宏，只使用内联函数。
任何在类中定义的函数自动地成为内联函数，但也可以使用i n l i n e关键字放在类外定义的函数前面使之成为内联函数。但为了使之有效，必须使函数体和声明结合在一起，否则，编译器将它作为普通函数对待。因此
inline int PlusOne(int x);
没有任何效果，仅仅只是声明函数（这不一定能够在稍后某个时候得到一个内联定义）。成功的方法如下：
inline int PlusOne(int x) { return ++x ;}
注意，编译器将检查函数参数列表使用是否正确，并返回值（进行必要的转换）。这些事情是预处理器无法完成的。假如对于上面的内联函数，我们写成一个预处理器宏的话，将有不想要的副作用。
一般应该把内联定义放在头文件里。当编译器看到这个定义时，它把函数类型（函数名+返回值）和函数体放到符号表里。当使用函数时，编译器检查以确保调用是正确的且返回值被正确使用，然后将函数调用替换为函数体，因而消除了开销。内联代码的确占用空间，但假如函数较小，这实际上比为了一个普通函数调用而产生的代码（参数压栈和执行C A L L）占用的空间还少。
在头文件里，内联函数默认为内部连接——即它是static, 并且只能在它被包含的编译单元看到。因而，只要它们不在相同的编译单元中声明，在内联函数和全局函数之间用同样的名字也不会在连接时产生冲突。
6、转换连接：
如果C + +中编写一个程序需要用到C库，那该怎么办呢？如果这样声明一个C函数：
float f(int a,char b);
C + +的编译器就会将这个名字变成像_ f _ i n t _ i n t之类的东西以支持函数重载（和类型安全连接）。然而，C编译器编译的库一般不做这样的转换，所以它的内部名为_ f。这样，连接器将无法解决我们C + +对f（）的调用。
C + +中提供了一个连接转换指定，它是通过重载e x t e r n关键字来实现的。e x t e r n后跟一个字符串来指定我们想声明的函数的连接类型，后面是函数声明。
extern "C" float f(int a,char b);
这就告诉编译器f ( )是C连接，这样就不会转换函数名。标准的连接类型指定符有“ C”和“C + +”两种，但编译器开发商可选择用同样的方法支持其他语言。
多数C + +编译器开发商在他们的头文件中处理转换连接指定，包括C和C + +，所以我们不用担心它们。
虽然标准的C + +只支持“C”和“C + +”两种连接转换指定，但用同样的方法可以实现对
其他语言的支持。
7、extern声明外部变量：
extern用在变量声明中常常有这样一个作用，你在*.c文件中声明了一个全局的变量，这个全局的变量如果要被引用，就放在*.h中并用extern来声明。
现代编译器一般采用按文件编译的方式，因此在编译时，各个文件中定义的全局变量是 互相透明的，i作为全局变量只能定义一次，也就是说，在编译时，全局变量的可见域限制在文件内部。下面举一个简单的例子。创建一个工程，里面含有A.cpp和B.cpp两个简单的C++源文件：
//A.cpp int i; void main() { } //B.cpp int i; 这两个文件极为简单，在A.cpp中我们定义了一个全局变量i，在B中我们也定义了一个全局变量i。 我们对A和B分别编译，都可以正常通过编译，但是进行链接的时候，却出现了错误，错误提示如下： Linking... B.obj : error LNK2005: "int i" (?i@@3HA) already defined in A.obj Debug/A.exe : fatal error LNK1169: one or more multiply defined symbols found Error executing link.exe. A.exe - 2 error(s), 0 warning(s) 这就是说，在编译阶段，各个文件中定义的全局变量相互是透明的，编译A时觉察不到B中也定义了i，同样，编译B时觉察不到A中也定义了i。 但是到了链接阶段，要将各个文件的内容“合为一体”，因此，如果某些文件中定义的全局变量名相同的话，在这个时候就会出现错误，也就是上面提示的重复定义的错误。 因此，各个文件中定义的全局变量名不可相同。 在链接阶段，各个文件的内容（实际是编译产生的obj文件）是被合并到一起的，因而，定义于某文件内的全局变量，在链接完成后，它的可见范围被扩大到了整个程序。 这样一来，按道理说，一个文件中定义的全局变量，可以在整个程序的任何地方被使用，举例说，如果A文件中定义了某全局变量，那么B文件中应可以使用该变量。修改我们的程序，加以验证： //A.cpp void main() { i = 100; //试图使用B中定义的全局变量 } //B.cpp int i; 编译结果如下： Compiling... A.cpp C:\Documents and Settings\wangjian\桌面\try extern\A.cpp(5) : error C2065: 'i' : undeclared identifier Error executing cl.exe. A.obj - 1 error(s), 0 warning(s) 编译错误。 其实出现这个错误是意料之中的，因为：文件中定义的全局变量的可见性扩展到整个程序是在链接完成之后，而在编译阶段，他们的可见性仍局限于各自的文件。 编译器的目光不够长远，编译器没有能够意识到，某个变量符号虽然不是本文件定义的，但是它可能是在其它的文件中定义的。 虽然编译器不够远见，但是我们可以给它提示，帮助它来解决上面出现的问题。这就是extern的作用了。 extern的原理很简单，就是告诉编译器：“你现在编译的文件中，有一个标识符虽然没有在本文件中定义，但是它是在别的文件中定义的全局变量，你要放行！” 我们为上面的错误程序加上extern关键字： //A.cpp extern int i; void main() { i = 100; //试图使用B中定义的全局变量 } //B.cpp int i;顺利通过编译，链接。
extern 函数1
常见extern放在函数的前面成为函数声明的一部分，那么，C语言的关键字extern在函数的声明中起什么作用？ 答案与分析： 如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用。即下述两个函数声明没有明显的区别： extern int f(); 和int f(); 当然，这样的用处还是有的，就是在程序中取代include “*.h”来声明函数，在一些复杂的项目中，我比较习惯在所有的函数声明前添加extern修饰。 extern 函数2 当函数提供方单方面修改函数原型时，如果使用方不知情继续沿用原来的extern申明，这样编译时编译器不会报错。但是在运行过程中，因为少了或者多了输入参数，往往会造成系统错误，这种情况应该如何解决？ 答案与分析： 目前业界针对这种情况的处理没有一个很完美的方案，通常的做法是提供方在自己的xxx_pub.h中提供对外部接口的声明，然后调用包涵该文件的头文件，从而省去extern这一步。以避免这种错误。 宝剑有双锋，对extern的应用，不同的场合应该选择不同的做法。