C/C++编译原理

转自：http://m.blog.csdn.net/blog/business122/21722039    http://m.blog.csdn.net/blog/business122/21722151

C/C++编译就是要将C/C++的代码映射到相应的机器码，以及讨论其中的内存管理模式，包括内存的分配，如何使用等等，整型、数组、指针等这些在内存中的实现机制。

C/C++的编译包括几个部分，分别是编译，汇编和连接。

1. 编译，就是将相应的高级语言代码映射到汇编语言，处理define，include等命令，加载外部的代码；

2. 汇编，就是将汇编语言映射到机器码；

3. 连接，造成相应的动态和静态连接库。动态链接库是在程序运行时动态的加载，静态链接库是直接拷贝进入程序，在程序执行时，这些静态链接库加载进来。

第一篇：     
首先是预编译，这一步能够粗略的认为只作了一件事情，那就是“宏展开”，也就是对那些#***的命令的一种展开。

      例如define MAX 1000就是创建起MAX和1000之间的对等关系，好在编译阶段进行替换。

      例如ifdef/ifndef就是从一个文件中有选择性的挑出一些符合条件的代码来交给下一步的编译阶段来处理。这里面最复杂的莫过于include了，其实也很简单，就是至关于把那个对应的文件里面的内容一会儿替换到这条include***语句的地方来。

      其次是编译，这一步很重要，编译是以一个个独立的文件做为单元的，一个文件就会编译出一个目标文件。（这里插入一点关于编译的文件的说明，编译器经过后缀名来辨识是否编译该文件，所以“.h”的头文件一律不理会，而“.cpp”的源文件一概都要被编译，我实验过把.h文件的后缀名改成.cpp，而后在include的地方相应的改成***.cpp，这样一来，编译器就会编译许多没必要要的头文件，只不过头文件里咱们一般只放置声明而不是定义，所以最后连接生成的可执行文件的大小是不会改变的）

      清楚编译是以一个个单独的文件为单元的，这一点很重要，所以编译只负责本单元的那些事，而对外部的事情一律不理会，在这一步里，咱们能够调用一个函数而没必要给出这个函数的定义，可是要在调用前获得这个函数的声明（其实这就是include的本质，不就是为了给你提早提供个声明而好让你使用吗？至于那个函数究竟是如何实现的，须要在连接这一步里去找函数的入口地址。所以提供声明的方式能够是用include把放在别的文件中的声明拿过来，也能够是在调用以前本身写一句void max(int,int);都行。），编译阶段剩下的事情就是分析语法的正确性之类的工做了。好啦，总结一下，能够粗略的认为编译阶段分两步：    

        第一步，检验函数或者变量是否存在它们的声明；

        第二步，检查语句是否符合C++语法。

最后一步是连接，它会把全部编译好的单元所有连接为一个总体文件，其实这一步能够比做一个“连线”的过程，好比A文件用了B文件中的函数，那么连接的这一步会创建起这个关联。连接时最重要的我认为是检查全局空间里面是否是有重复定义或者缺失定义。这也就解释了为何咱们通常不在头文件中出现定义，由于头文件有可能被释放到多个源文件中，每一个源文件都会单独编译，连接时就会发现全局空间中有多个定义了。

标准C和C++将编译过程定义为9个阶段(Phases of Translation)：

1.字符映射(Character Mapping)

    文件中的物理源字符被映射到源字符集中，其中包括三字符运算符的替换、控制字符(行尾的回车换行)的替换。许多非美式键盘不支持基本源字符集中的一些字符，文件中可用三字符来代替这些基本源字符，以??为前导。但若是所用键盘是美式键盘，有些编译器可能不对三字符进行查找和替换，须要增长-trigraphs编译参数。在C++程序中，任何不在基本源字符集中的字符都被它的通用字符名替换。

2.行合并(Line Splicing)

    以反斜杠/结束的行和它接下来的行合并。

3.标记化(Tokenization)

    每一条注释被一个单独的空字符所替换。C++双字符运算符被识别为标记(为了开发可读性更强的程序，C++为非ASCII码开发者定义了一套双字符运算符集和新的保留字集)。源代码被分析成预处理标记。

4.预处理(Preprocessing)

    调用预处理指令并扩展宏。使用#include指令包含的文件，重复步骤1到4。上述四个阶段统称为预处理阶段。

5.字符集映射(Character-set Mapping)

    源字符集成员、转义序列被转换成等价的执行字符集成员。例如：'/a'在ASCII环境下会被转换成值为一个字节，值为7。

6.字符串链接(String Concatenation)

    相邻的字符串被链接。例如："""hahaha""huohuohuo"将成为"hahahahuohuohuo"。

7.翻译(Translation)

    进行语法和语义分析编译，并翻译成目标代码。

8.处理模板

    处理模板实例。

9.链接(Linkage)

    解决外部引用的问题，准备好程序映像以便执行。

第二篇：

1、C++编译模式
一般，在一个C++程序中，只包含两类文件——.cpp文件和.h文件。其中，.cpp文件被称做C++源文件，里面放的都是C++的源代码；而.h文件则被称做C++头文件，里面放的也是C++的源代码。
C+ +语言支持“分别编译”（separate compilation）。也就是说，一个程序全部的内容，能够分红不一样的部分分别放在不一样的.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、什么是头文件
很显然，答案是不可能。可是有一个很简单地办法，能够帮助程序员们省去记住那么多函数原型的麻烦：咱们能够把那几百个函数的声明语句全都先写好，放在一个文件里，等到程序员须要它们的时候，就把这些东西所有copy进他的源代码中。
这 个方法当然可行，但仍是太麻烦，并且还显得很笨拙。因而，头文件即可以发挥它的做用了。所谓的头文件，其实它的内容跟.cpp文件中的内容是同样的，都是 C++的源代码。但头文件不用被编译。咱们把全部的函数声明所有放进一个头文件中，当某一个.cpp源文件须要它们时，它们就能够经过一个宏命令 “#include”包含进这个.cpp文件中，从而把它们的内容合并到.cpp文件中去。当.cpp文件被编译时，这些被包含进去的.h文件的做用便发 挥了。
举一个例子吧，假设全部的数学函数只有两个：f1和f2，那么咱们把它们的定义放在math.cpp里：
/* math.cpp */
double f1()
{
//do something here....
return;
}
double f2(double a)
{
//do something here...
return a * a;
}
/* end of math.cpp */
并把“这些”函数的声明放在一个头文件math.h中：
/* math.h */

double f1();
double f2(double);
/* end of math.h */
在另外一个文件main.cpp中，我要调用这两个函数，那么就只须要把头文件包含进来：
/* main.cpp */
#include "math.h"
main()
{
int number1 = f1();
int number2 = f2(number1);
}
/* end of main.cpp */
这 样，即是一个完整的程序了。须要注意的是，.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的内容已经发生了改变：
/* ~main.cpp */
double f1();
double f2(double);
main()
{
int number1 = f1();
int number2 = f2(number1);
}
/* end of ~main.cpp */
很少很多，刚恰好。同理可知，若是咱们除了main.cpp之外，还有其余的不少.cpp文件也用到了f1和f2函数的话，那么它们也统统只须要在使用这两个函数前写上一句#include "math.h"就好了。

4、头文件中应该写什么
通 过上面的讨论，咱们能够了解到，头文件的做用就是被其余的.cpp包含进去的。它们自己并不参与编译，但实际上，它们的内容却在多个.cpp文件中获得了 编译。经过“定义只能有一次”的规则，咱们很容易能够得出，头文件中应该只放变量和函数的声明，而不能放它们的定义。由于一个头文件的内容其实是会被引 入到多个不一样的.cpp文件中的，而且它们都会被编译。放声明固然没事，若是放了定义，那么也就至关于在多个文件中出现了对于一个符号（变量或函数）的定 义，纵然这些定义都是相同的，但对于编译器来讲，这样作不合法。
因此，应该记住的一点就是，.h头文件中，只能存在变量或者函数的声明， 而不要放定义。即，只能在头文件中写形如：extern int a;和void f();的句子。这些才是声明。若是写上int a;或者void f() {}这样的句子，那么一旦这个头文件被两个或两个以上的.cpp文件包含的话，编译器会立马报错。（关于extern，前面有讨论过，这里再也不讨论定义跟 声明的区别了。）
可是，这个规则是有三个例外的。
一，头文件中能够写const对象的定义。由于全局的const对象默 认是没有extern的声明的，因此它只在当前文件中有效。把这样的对象写进头文件中，即便它被包含到其余多个.cpp文件中，这个对象也都只在包含它的 那个文件中有效，对其余文件来讲是不可见的，因此便不会致使多重定义。同时，由于这些.cpp文件中的该对象都是从一个头文件中包含进去的，这样也就保证 了这些.cpp文件中的这个const对象的值是相同的，可谓一箭双雕。同理，static对象的定义也能够放进头文件。
二，头文件中可 以写内联函数（inline）的定义。由于inline函数是须要编译器在遇到它的地方根据它的定义把它内联展开的，而并不是是普通函数那样能够先声明再链 接的（内联函数不会连接），因此编译器就须要在编译时看到内联函数的完整定义才行。若是内联函数像普通函数同样只能定义一次的话，这事儿就难办了。由于在 一个文件中还好，我能够把内联函数的定义写在最开始，这样能够保证后面使用的时候均可以见到定义；可是，若是我在其余的文件中还使用到了这个函数那怎么办 呢？这几乎没什么太好的解决办法，所以C++规定，内联函数能够在程序中定义屡次，只要内联函数在一个.cpp文件中只出现一次，而且在全部的.cpp文 件中，这个内联函数的定义是同样的，就能经过编译。那么显然，把内联函数的定义放进一个头文件中是很是明智的作法。

三，头文件中能够写类 （class）的定义。由于在程序中建立一个类的对象时，编译器只有在这个类的定义彻底可见的状况下，才能知道这个类的对象应该如何布局，因此，关于类的 定义的要求，跟内联函数是基本同样的。因此把类的定义放进头文件，在使用到这个类的.cpp文件中去包含这个头文件，是一个很好的作法。在这里，值得一提 的是，类的定义中包含着数据成员和函数成员。数据成员是要等到具体的对象被建立时才会被定义（分配空间），但函数成员倒是须要在一开始就被定义的，这也就 是咱们一般所说的类的实现。通常，咱们的作法是，把类的定义放在头文件中，而把函数成员的实现代码放在一个.cpp文件中。这是能够的，也是很好的办法。 不过，还有另外一种办法。那就是直接把函数成员的实现代码也写进类定义里面。在C++的类中，若是函数成员在类的定义体中被定义，那么编译器会视这个函数为 内联的。所以，把函数成员的定义写进类定义体，一块儿放进头文件中，是合法的。注意一下，若是把函数成员的定义写在类定义的头文件中，而没有写进类定义中， 这是不合法的，由于这个函数成员此时就不是内联的了。一旦头文件被两个或两个以上的.cpp文件包含，这个函数成员就被重定义了。

5、头文件中的保护措施
考 虑一下，若是头文件中只包含声明语句的话，它被同一个.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使得编译器能够根据这个名字是否被定义，再决定要不要继 续编译该头文中后续的内容。这个方法虽然简单，可是写头文件时必定记得写进去。

[转]C++编译器与连接器工做原理

这里并没不是讨论大学课程中所学的《编译原理》，只是写一些我本身对C++编译器及连接器的工做原理的理解和见解吧，以个人水平，还达不到讲解编译原理（这个很复杂，大学时几乎没学明白）。

要明白的几个概念：

    一、编译：编译器对源文件进行编译，就是把源文件中的文本形式存在的源代码翻译成机器语言形式的目标文件的过程，在这个过程当中，编译器会进行一系列的语法检查。若是编译经过，就会把对应的CPP转换成OBJ文件。

    二、编译单元：根据C++标准，每个CPP文件就是一个编译单元。每一个编译单元之间是相互独立而且互相不可知。

    三、目标文件：由编译所生成的文件，以机器码的形式包含了编译单元里全部的代码和数据，还有一些期他信息，如未解决符号表，导出符号表和地址重定向表等。目标文件是以二进制的形式存在的。

    根据C++标准，一个编译单元（Translation Unit）是指一个.cpp文件以及这所include的全部.h文件，.h文件里面的代码将会被扩展到包含它的.cpp文件里，而后编译器编译该.cpp文件为一个.obj文件，后者拥有PE（Portable Executable，即Windows可执行文件）文件格式，而且自己包含的就是二进制代码，可是不必定能执行，由于并不能保证其中必定有main函数。当编译器将一个工程里的全部.cpp文件以分离的方式编译完毕后，再由连接器进行连接成为一个.exe或.dll文件。

下面让咱们来分析一下编译器的工做过程：

咱们跳过语法分析，直接来到目标文件的生成，假设咱们有一个A.cpp文件，以下定义：

    int n = 1;

    void FunA()

    {

        ++n;

    }

    它编译出来的目标文件A.obj就会有一个区域（或者说是段），包含以上的数据和函数，其中就有n、FunA，以文件偏移量形式给出可能就是下面这种状况：

    偏移量    内容    长度

    0x0000    n       4

    0x0004    FunA    ??

    注意：这只是说明，与实际目标文件的布局可能不同，??表示长度未知，目标文件的各个数据可能不是连续的，也不必定是从0x0000开始。

    FunA函数的内容可能以下：

    0x0004 inc DWORD PTR[0x0000]

    0x00?? ret

    这时++n已经被翻译成inc DWORD PTR[0x0000]，也就是说把本单元0x0000位置的一个DWORD（4字节）加1。

    有另一个B.cpp文件，定义以下：

    extern int n;

    void FunB()

    {

        ++n;

    }

    它对应的B.obj的二进制应该是：

    偏移量    内容    长度

    0x0000    FunB    ??

    这里为何没有n的空间呢，由于n被声明为extern，这个extern关键字就是告诉编译器n已经在别的编译单元里定义了，在这个单元里就不要定义了。因为编译单元之间是互不相关的，因此编译器就不知道n究竟在哪里，因此在函数FunB就没有办法生成n的地址，那么函数FunB中就是这样的：

    0x0000 inc DWORD PTR[????]

    0x00?? ret

    那怎么办呢？这个工做就只能由连接器来完成了。

    为了能让连接器知道哪些地方的地址没有填好（也就是还????），那么目标文件中就要有一个表来告诉连接器，这个表就是“未解决符号表”，也就是unresolved symbol table。一样，提供n的目标文件也要提供一个“导出符号表”也就是exprot symbol table，来告诉连接器本身能够提供哪些地址。

    好，到这里咱们就已经知道，一个目标文件不只要提供数据和二进制代码外，还至少要提供两个表：未解决符号表和导出符号表，来告诉连接器本身须要什么和本身能提供些什么。那么这两个表是怎么创建对应关系的呢？这里就有一个新的概念：符号。在C/C++中，每个变量及函数都会有本身的符号，如变量n的符号就是n，函数的符号会更加复杂，假设FunA的符号就是_FunA（根据编译器不一样而不一样）。

    因此，

    A.obj的导出符号表为

    符号    地址

    n       0x0000

    _FunA   0x0004

    未解决符号为空（由于他没有引用别的编译单元里的东西）。

    B.obj的导出符号表为

    符号    地址

    _FunB   0x0000

    未解决符号表为

    符号    地址

    n       0x0001

    这个表告诉连接器，在本编译单元0x0001位置有一个地址，该地址不明，但符号是n。

    在连接的时候，连接在B.obj中发现了未解决符号，就会在全部的编译单元中的导出符号表去查找与这个未解决符号相匹配的符号名，若是找到，就把这个符号的地址填到B.obj的未解决符号的地址处。若是没有找到，就会报连接错误。在此例中，在A.obj中会找到符号n，就会把n的地址填到B.obj的0x0001处。

    可是，这里还会有一个问题，若是是这样的话，B.obj的函数FunB的内容就会变成inc DWORD PTR[0x000]（由于n在A.obj中的地址是0x0000）,因为每一个编译单元的地址都是从0x0000开始，那么最终多个目标文件连接时就会致使地址重复。因此连接器在连接时就会对每一个目标文件的地址进行调整。在这个例子中，假如B.obj的0x0000被定位到可执行文件的0x00001000上，而A.obj的0x0000被定位到可执行文件的0x00002000上，那么实现上对连接器来讲，A.obj的导出符号地地址都会加上0x00002000，B.obj全部的符号地址也会加上0x00001000。这样就能够保证地址不会重复。

    既然n的地址会加上0x00002000，那么FunA中的inc DWORD PTR[0x0000]就是错误的，因此目标文件还要提供一个表，叫地址重定向表，address redirect table。

    总结一下：

    目标文件至少要提供三个表：未解决符号表，导出符号表和地址重定向表。

    未解决符号表：列出了本单元里有引用可是不在本单元定义的符号及其出现的地址。

    导出符号表：提供了本编译单元具备定义，而且能够提供给其余编译单元使用的符号及其在本单元中的地址。

    地址重定向表：提供了本编译单元全部对自身地址的引用记录。

    连接器的工做顺序：

    当连接器进行连接的时候，首先决定各个目标文件在最终可执行文件里的位置。而后访问全部目标文件的地址重定义表，对其中记录的地址进行重定向（加上一个偏移量，即该编译单元在可执行文件上的起始地址）。而后遍历全部目标文件的未解决符号表，而且在全部的导出符号表里查找匹配的符号，并在未解决符号表中所记录的位置上填写实现地址。最后把全部的目标文件的内容写在各自的位置上，再做一些另的工做，就生成一个可执行文件。

    说明：实现连接的时候会更加复杂，通常实现的目标文件都会把数据，代码分红好向个区，重定向按区进行，但原理都是同样的。

    明白了编译器与连接器的工做原理后，对于一些连接错误就容易解决了。

    下面再看一看C/C++中提供的一些特性：

    extern：这就是告诉编译器，这个变量或函数在别的编译单元里定义了，也就是要把这个符号放到未解决符号表里面去（外部连接）。

    static：若是该关键字位于全局函数或者变量的声明前面，代表该编译单元不导出这个函数或变量，因些这个符号不能在别的编译单元中使用（内部连接）。若是是static局部变量，则该变量的存储方式和全局变量同样，可是仍然不导出符号。 

    默认连接属性：对于函数和变量，默认连接是外部连接，对于const变量，默认内部连接。

外部连接的利弊：外部连接的符号在整个程序范围内都是可使用的，这就要求其余编译单元不能导出相同的符号（否则就会报duplicated external symbols）。

内部连接的利弊：内部连接的符号不能在别的编译单元中使用。但不一样的编译单元能够拥有一样的名称的符号。

    为何头文件里通常只能够有声明不能有定义：头文件能够被多个编译单元包含，若是头文件里面有定义的话，那么每一个包含这头文件的编译单元都会对同一个符号进行定义，若是该符号为外部连接，则会致使duplicated external symbols连接错误。

    为何公共使用的内联函数要定义于头文件里：由于编译时编译单元之间互不知道，若是内联被定义于.cpp文件中，编译其余使用该函数的编译单元的时候没有办法找到函数的定义，因些没法对函数进行展开。因此若是内联函数定义于.cpp里，那么就只有这个.cpp文件能使用它。