2023-04-14 20:44
1 C/C++ 编译模式通常，在一个 C++ 程序中，只包含两类文件—— .cpp 文件和 .h 文件。
其中，.cpp 文件被称作 C++ 源文件，里面放的都是 C++ 的源代码；而 .h 文件则被称作 C++ 头文件，里面放的也是 C++ 的源代码。
C++ 语言支持“分别编译”（separatecompilation）。
也就是说，一个程序所有的内容，可以分成不同的部分分别放在不同的 .cpp 文件里。
.cpp 文件里的东西都是相对独立的，在编译（compile）时不需要与其他文件互通，只需要在编译成目标文件后再与其他的目标文件做一次链接（link）就行了。
比如，在文件 a.cpp 中定义了一个全局函数 "void a(){}"，而在文件 b.cpp 中需要调用这个函数。
即使这样，文件 a.cpp 和文件 b.cpp 并不需要相互知道对方的存在，而是可以分别地对它们进行编译，编译成目标文件之后再链接，整个程序就可以运行了。
这是怎么实现的呢？从写程序的角度来讲，很简单。
在文件 b.cpp 中，在调用 "void a()" 函数之前，先声明一下这个函数 "void a();"，就可以了。
这是因为编译器在编译 b.cpp 的时候会生成一个符号表（symbol table），像 "void a()" 这样的看不到定义的符号，就会被存放在这个表中。
再进行链接的时候，编译器就会在别的目标文件（实现文件）中去寻找这个符号的定义。
一旦找到了，程序也就可以顺利地生成了，如果找不到，则会产生链接错误。
注意这里提到了两个概念，一个是"定义"，一个是"声明"。
简单地说，"定义"就是把一个符号完完整整地描述出来：它是变量还是函数，返回什么类型，需要什么参数等等。
而"声明"则只是声明这个符号的存在，即告诉编译器，这个符号是在其他文件中定义的，我这里先用着，你链接的时候再到别的地方去找找看它到底是什么吧。
定义的时候要按 C++ 语法完整地定义一个符号（变量或者函数），而声明的时候就只需要写出这个符号的原型了。
需要注意的是，一个符号，在整个程序中可以被声明多次，但却要且仅要被定义一次。
试想，如果一个符号出现了两种不同的定义，编译器该听谁的？这种机制给 C++ 程序员们带来了很多好处，同时也引出了一种编写程序的方法。
考虑一下，如果有一个很常用的函数 "void f() {}"，在整个程序中的许多 .cpp 文件中都会被调用，那么，我们就只需要在一个文件中定义这个函数，而在其他的文件中声明这个函数就可以了。
2 为什么C++要分为头文件和源文件？这是否和外部调用有关？为什么现在大多数语言都没有采用这种设计？为什么调用dll有时需要使用Windows提供的API导出函数或者结构，而不能直接include xxxx.h或者像C#写的dll那样在项目中添加引用然后直接using xxxx。
需要从C/C++历史演变的角度回答下这个问题。
上世纪70年代初，C语言初始版本被设计出来时，是没有头文件的。
这一点与后世的Java只有.java文件，C#只有.cs文件很相似。
即使是现代的C编译器，头文件也不是必须的。
我使用下面这个例子说明：//alpha.cint main(){ print_hello();}//beta.cvoid print_hello(){ puts("hello");}上例只有两个源文件，alpha.c与beta.c。
其中alpha.c使用了一个自定义函数print_hello，beta.c中使用了标准库函数puts。
注意：alpha.c与beta.c都没有包含任何头文件。
你可以使用MSCL编译器来编译：cl/Fe:program.exealpha.cbeta.c或者GCC以及Clang：clang-oprogramalpha.cbeta.c这样会得到一个名为program的可执行文件，并且它可以正常工作。
以beta.c为例：当beta.c被编译时，编译器解析到名为puts的符号，虽然它是未定义的，但从语法上可以判断puts是一个函数，故而将其认定为函数，作为外部符号等待链接就可以了（倘若alpha，beta是C++源文件，编译无法通过，这个后文会做解释）。
下面我用ASCII字符绘制的“编译”与“链接”流程图：alpha.c -> alpha.obj program.exe /beta.c -> beta.obj相信这个流程作为基础知识已广为人知，我就不再赘述了。
问题在于：当初为什么要采用这样的设计？将“编译”、“链接”两个步骤区分开，并让用户可知是什么意图？其实这是上世纪60、70年代各语言的“套路”做法，因为各个obj文件可能并不是同一种语言源文件编译得到的，它们可能来自于C，可能是汇编、也可能是Fortran这样与C一样的高级语言。
即是说“编译”、“链接”的流程其实是这样的：alpha.c -> alpha.obj beta.asm -> beta.obj --> program.exe /gamma.f -> gamma.obj所以，编译阶段C源文件（当然也包括其它语言的源文件）是不与其它源文件产生关系的，因为编译器（这里指的是狭义的编译器，不包括链接器）本身有可能并不能识别其它源。
说到这里，定然有人要问：连函数参数和返回值都不知道，直接链接然后调用，会不会出现问题。
答案是：不会，至少当时不会。
因为当时的C只有一种数据类型，即“字长”（同时代的大多数语言也一样）。
我们考虑这样一个函数调用：n=add(1,2,3,4);首先，add函数的调用者，将4个参数自右向左压入栈，即是说压栈完成后1在栈顶，4在栈底；然后，add被调用，对于被调用者（也就是add）而言，栈长度是不可知的，但第一个参数在栈顶，往下一个字长就是第二个参数，以此类推，所以栈长度不可知并不会带来问题；add处理完成后，将返回值放入数据寄存器，并返回；调用者弹栈，因为压栈操作是调用者实施的，故而栈长度、压栈前栈顶位置等信息调用者是可知的，可以调用者有能力保持栈平衡。
这里说一个题外话：倘若调用者压栈的参数不够，那会如何？答案是被调用者会在栈上读到垃圾数据；又问：倘若被调用者没有返回值，那会如何？答案是调用者会在寄存器得到垃圾数据；再问：如此在代码维护上不会有问题吗？答案是从后来的实践上看，问题不大，其实可以对比下如今python、lua等弱类型语言。
通过上面的论述，我们得知C语言设计之初是没有头文件的，调用某个函数也不需要提前声明。
不过好景不长，后来出现了不同的数据类型。
例如出于可移植性和内存节省的考虑，出现了short int、long int；为了加强对块处理的IO设备的支持，出现了char。
如此就带来了一个问题，即函数的调用者不知道压栈的长度。
例如有函数调用：add(x,y);调用者知道add是一个函数，也知道需要将x、y压栈，但应该是先压2个字节、再压4个字节喃，还是先压4个字节，再压2个字节喃；还是连续压2个4字节喃？这里需要说明一下，在上世纪80年代intel8084系的处理器普及以前，并没有公认的“字节(byte)”概念，以上只是我举例方便。
紧接着结构体等特性陆续引入，问题变得更复杂。
在这种情况下，函数调用需要提前声明，以便让调用者得知函数的参数与返回值尺寸（结构体使用也需要提前声明，以便让调用者知道其成员、尺寸、内存对其规则等，这里不赘述了）。
这里有人可能就会问了：为什么在编译一个源文件时，不去其它源文件查找声明，就如后世的Java、C#一样。
主要原因上文已经说过：C源文件在编译时不与其它源产生关系，因为其它源可能根本就不是C；此外使用include将声明插入到源文件中，技术实现毕竟很简单，也可以说是一种技术惯性。
又后来出现了C++，由于函数重载、模板等特性，当编译器识别到一个函数，不仅是参数与返回值尺寸，连调用哪一个函数都无法从函数名辨别了（即上文的“倘若alpha，beta是C++源文件，编译无法通过，这个后文会做解释”一语）。
函数与数据结构需要提前声明才能使用更是不可或缺。
对于函数声明，一个函数还好对付，声明起来也就一句话。
但是，如果函数多了，比如是一大堆的数学函数，有好几百个，那怎么办？能保证每个程序员都可以完完全全地把所有函数的形式都准确地记下来并写出来吗？很显然，答案是不可能。
但是有一个很简单地办法，可以帮助程序员们省去记住那么多函数原型的麻烦：我们可以把那几百个函数的声明语句全都先写好，放在一个文件里，等到程序员需要它们的时候，就把这些东西全部 copy 进他的源代码中。
这个方法固然可行，但还是太麻烦，而且还显得很笨拙。
于是，头文件便可以发挥它的作用了。
所谓的头文件，其实它的内容跟 .cpp 文件中的内容是一样的，都是 C++ 的源代码。
但头文件不用被编译。
我们把所有的函数声明全部放进一个头文件中，当某一个 .cpp 源文件需要它们时，它们就可以通过一个宏命令 "#include" 包含进这个 .cpp 文件中，从而把它们的内容合并到 .cpp 文件中去。
当 .cpp 文件被编译时，这些被包含进去的 .h 文件的作用便发挥了。
举一个例子吧，假设所有的数学函数只有两个：f1 和 f2，那么我们把它们的定义放在 math.cpp 里：double f1(){ //do something here.... return;}double f2(double a){ //do something here... return a * a;}并把"这些"函数的声明放在一个头文件 math.h 中：double f1();double f2(double);在另一个文件main.cpp中，我要调用这两个函数，那么就只需要把头文件包含进来：#include "math.h"main(){ int number1=f1(); int number2=f2(number1);}这样，便是一个完整的程序了。
需要注意的是，.h 文件不用写在编译器的命令之后，但它必须要在编译器找得到的地方（比如跟 main.cpp 在一个目录下）main.cpp 和 math.cpp 都可以分别通过编译，生成 main.o 和 math.o，然后再把这两个目标文件进行链接，程序就可以运行了。
3 #include#include 是一个来自 C 语言的宏命令，它在编译器进行编译之前，即在预编译的时候就会起作用。
#include 的作用是把它后面所写的那个文件的内容，完完整整地、一字不改地包含到当前的文件中来。
值得一提的是，它本身是没有其它任何作用与副功能的，它的作用就是把每一个它出现的地方，替换成它后面所写的那个文件的内容。
简单的文本替换，别无其他。
因此，main.cpp 文件中的第一句（#include"math.h"），在编译之前就会被替换成 math.h 文件的内容。
即在编译过程将要开始的时候，main.cpp 的内容已经发生了改变：double f1();double f2(double);main(){ int number1=f1(); int number2=f2(number1);}不多不少，刚刚好。
同理可知，如果我们除了 main.cpp 以外，还有其他的很多 .cpp 文件也用到了 f1 和 f2 函数的话，那么它们也通通只需要在使用这两个函数前写上一句 #include "math.h" 就行了。
系统自带的头文件用尖括号括起来，这样编译器会在系统文件目录下查找。
用户自定义的文件用双引号括起来，编译器首先会在用户目录下查找，然后在到 C++ 安装目录（比如 VC 中可以指定和修改库文件查找路径，Unix 和 Linux 中可以通过环境变量来设定）中查找，最后在系统文件中查找。
4 头文件如何来关联源文件这个问题实际上是说，已知头文件 "a.h" 声明了一系列函数，"b.cpp" 中实现了这些函数，那么如果我想在 "c.cpp" 中使用 "a.h" 中声明的这些在 "b.cpp"中实现的函数，通常都是在 "c.cpp" 中使用 #include "a.h"，那么 c.cpp 是怎样找到 b.cpp 中的实现呢？其实 .cpp 和 .h 文件名称没有任何直接关系，很多编译器都可以接受其他扩展名。
如cpp 文件用 .cc 扩展名。
在 Turbo C 中，采用命令行方式进行编译，命令行参数为文件的名称，默认的是 .cpp 和 .h，但是也可以自定义为 .xxx 等等。
编译器预处理时，要对 #include 命令进行"文件包含处理"，这也正说明了，为什么很多编译器并不 care 到底这个文件的后缀名是什么----因为 #include 预处理就是完成了一个"复制并插入代码"的工作。
编译的时候，并不会去找 b.cpp 文件中的函数实现，只有在 link 的时候才进行这个工作。
我们在 b.cpp 或 c.cpp 中用 #include "a.h" 实际上是引入相关声明，使得编译可以通过，程序并不关心实现是在哪里，是怎么实现的。
源文件编译后成生了目标文件（.o 或 .obj 文件），目标文件中，这些函数和变量就视作一个个符号。
在 link 的时候，需要在 makefile 里面说明需要连接哪个 .o 或 .obj 文件（在这里是 b.cpp 生成的 .o 或 .obj 文件），此时，连接器会去这个 .o 或 .obj 文件中找在 b.cpp 中实现的函数，再把他们 build 到 makefile 中指定的那个可以执行文件中。
在 Unix下，甚至可以不在源文件中包括头文件，只需要在 makefile 中指名即可（不过这样大大降低了程序可读性，是个不好的习惯）。
在 VC 中，一般情况下不需要自己写 makefile，只需要将需要的文件都包括在 project中，VC 会自动帮你把 makefile 写好。
通常，C++ 编译器会在每个 .o 或 .obj 文件中都去找一下所需要的符号，而不是只在某个文件中找或者说找到一个就不找了。
因此，如果在几个不同文件中实现了同一个函数，或者定义了同一个全局变量，链接的时候就会提示 "redefined"。
5 头文件实现了接口的功能函数的声明写在头文件中，实现放在源文件中，以及分开编译的机制，对于函数的使用者来说，只需通过头文件便可知道有哪些函数可供使用以及如何使用，而无需关注其实现的具体细节。
对于函数的实现者来说，一方面可以隐藏函数的实现，另一方面，更新函数的实现也无须使用者修改其调用函数的代码，也就是说，只是保持头文件（接口）的稳定性，而具体实现可以随时更新，不会对函数使用者产生影响。
6、头文件中应该写什么通过上面的讨论，我们可以了解到，头文件的作用就是被其他的 .cpp 包含进去的。
它们本身并不参与编译，但实际上，它们的内容却在多个 .cpp 文件中得到了编译。
通过"定义只能有一次"的规则，我们很容易可以得出，头文件中应该只放变量和函数的声明，而不能放它们的定义。
因为一个头文件的内容实际上是会被引入到多个不同的 .cpp 文件中的，并且它们都会被编译。
放声明当然没事，如果放了定义，那么也就相当于在多个文件中出现了对于一个符号（变量或函数）的定义，纵然这些定义都是相同的，但对于编译器来说，这样做不合法。
所以，应该记住的一点就是，.h头文件中，只能存在变量或者函数的声明，而不要放定义。
即，只能在头文件中写形如：extern int a; 和 void f(); 的句子。
这些才是声明。
如果写上 int a;或者 void f() {} 这样的句子，那么一旦这个头文件被两个或两个以上的 .cpp 文件包含的话，编译器会立马报错。
但是，这个规则是有三个例外的:6.1 头文件中可以写 const 对象的定义。
因为全局的 const 对象默认是没有 extern 的声明的，所以它只在当前文件中有效。
把这样的对象写进头文件中，即使它被包含到其他多个 .cpp 文件中，这个对象也都只在包含它的那个文件中有效，对其他文件来说是不可见的，所以便不会导致多重定义。
同时，因为这些 .cpp 文件中的该对象都是从一个头文件中包含进去的，这样也就保证了这些 .cpp 文件中的这个 const 对象的值是相同的，可谓一举两得。
同理，static 对象的定义也可以放进头文件。
6.2 头文件中可以写内联函数（inline）的定义。
因为inline函数是需要编译器在遇到它的地方根据它的定义把它内联展开的，而并非是普通函数那样可以先声明再链接的（内联函数不会链接），所以编译器就需要在编译时看到内联函数的完整定义才行。
如果内联函数像普通函数一样只能定义一次的话，这事儿就难办了。
因为在一个文件中还好，我可以把内联函数的定义写在最开始，这样可以保证后面使用的时候都可以见到定义；但是，如果我在其他的文件中还使用到了这个函数那怎么办呢？这几乎没什么太好的解决办法，因此 C++ 规定，内联函数可以在程序中定义多次，只要内联函数在一个 .cpp 文件中只出现一次，并且在所有的 .cpp 文件中，这个内联函数的定义是一样的，就能通过编译。
那么显然，把内联函数的定义放进一个头文件中是非常明智的做法。
6.3 头文件中可以写类（class）的定义。
因为在程序中创建一个类的对象时，编译器只有在这个类的定义完全可见的情况下，才能知道这个类的对象应该如何布局，所以，关于类的定义的要求，跟内联函数是基本一样的。
所以把类的定义放进头文件，在使用到这个类的 .cpp 文件中去包含这个头文件，是一个很好的做法。
在这里，值得一提的是，类的定义中包含着数据成员和函数成员。
数据成员是要等到具体的对象被创建时才会被定义（分配空间），但函数成员却是需要在一开始就被定义的，这也就是我们通常所说的类的实现。
一般，我们的做法是，把类的定义放在头文件中，而把函数成员的实现代码放在一个 .cpp 文件中。
这是可以的，也是很好的办法。
不过，还有另一种办法。
那就是直接把函数成员的实现代码也写进类定义里面。
在 C++ 的类中，如果函数成员在类的定义体中被定义，那么编译器会视这个函数为内联的。
因此，把函数成员的定义写进类定义体，一起放进头文件中，是合法的。
注意一下，如果把函数成员的定义写在类定义的头文件中，而没有写进类定义中，这是不合法的，因为这个函数成员此时就不是内联的了。
一旦头文件被两个或两个以上的 .cpp 文件包含，这个函数成员就被重定义了。
综上所述，.h文件可以包含：函数的声明；静态函数的定义；结构体的声明；类成员数据的声明，但不能赋值；类静态数据成员的定义和赋值，但不建议，只是个声明就好；类的成员函数的声明；非类成员函数的声明；常数的定义：如：constint a=5;类的内联函数的定义；不能包含：所有非静态变量（不是类的数据成员）的声明（对于C来说，除了extern，声明就是定义）；默认命名空间声明不要放在头文件，using namespace std;等应放在.cpp中，在 .h 文件中使用 std::string；7 头文件中的保护措施考虑一下，如果头文件中只包含声明语句的话，它被同一个 .cpp 文件包含再多次都没问题——因为声明语句的出现是不受限制的。
然而，上面讨论到的头文件中的三个例外也是头文件很常用的一个用处。
那么，一旦一个头文件中出现了上面三个例外中的任何一个，它再被一个 .cpp 包含多次的话，问题就大了。
因为这三个例外中的语法元素虽然"可以定义在多个源文件中"，但是"在一个源文件中只能出现一次"。
设想一下，如果 a.h 中含有类 A 的定义，b.h 中含有类 B 的定义，由于类B的定义依赖了类 A，所以 b.h 中也 #include了a.h。
现在有一个源文件，它同时用到了类A和类B，于是程序员在这个源文件中既把 a.h 包含进来了，也把 b.h 包含进来了。
这时，问题就来了：类A的定义在这个源文件中出现了两次！于是整个程序就不能通过编译了。
你也许会认为这是程序员的失误——他应该知道 b.h 包含了 a.h ——但事实上他不应该知道。
使用 "#define" 配合条件编译可以很好地解决这个问题。
在一个头文件中，通过 #define 定义一个名字，并且通过条件编译 #ifndef...#endif 使得编译器可以根据这个名字是否被定义，再决定要不要继续编译该头文中后续的内容。
这个方法虽然简单，但是写头文件时一定记得写进去。
－End－
