谈 c++编译

谈 c++编译

过去一周，半夜刨书，这篇文用来记录我的一些猜想、实验

废话不多，上车

---

数据交互

最终控制的是我们的I/O设备，主存释放字节流，作为与IO进行数据交换的直接港口，主存被要求速度必须要快，但受制于成本，所以产生了一种折中的办法就是缓存。缓存往往分成多个级别，越接近I/O的就会越快，越接近CPU的就会越慢，这种分等级制度在某种程度上起到了缓冲的作用。但不可避免的是，当I/O数据量非常大的时候，主存往往会请求硬盘帮忙，将主存部分需要存储的数据暂时地存储到硬盘上，这就是虚拟内存的概念。一旦启用这种方式，就会显得很卡（卡顿）。使得应用程序认为它现在拥有的是连续的可用的内存（一个连续完整的地址空间），而实际上，它通常是被分隔成多个物理内存碎片，还有部分暂时存储在外部磁盘存储器上，在需要时进行数据交换。

怎么做到内存看起来是连续的？

实际上物理地址是不连续的，而是给物理地址的编号是连续的，（很久之前看数学电路和微机原理的时候，会说到一个ram分配地址），按照事先约定好的规则，可以使它的地址号读取是连续的。比如说奇偶地址位的读取来满足cpu的设置，intel8086的cpu有一个管脚说明是奇偶读取地址，为了满足的它的整体的一个架构，ram和译码器什么的组合起来让cpu看上去真的是在读奇偶地址的。（别问我在哪看的，先把大学课本看熟了再问）

程序的生命周期：

编译、链接两个阶段。

c/c++ ----->编译-------> 汇编程序-------->链接----------> 二进制文件
------->装载--------->赋予绝对地址（可寻址）-------->执行

1. 编译
   输入/输出：c/c++

使用一个特殊的文本处理程序，将宏进行替换。将include关键字标识的含有特定文件包含到源码文件中，将define语句指定的值转换成常量，将ifndef或ifdef、eleif和endif做相应的处理。

2. 语言分析阶段

输入/输出：c/c++

最终得到一个精简的、符合语法、语义的代码。有以下的几个方面的过程：

• 词法分析：将源代码分割成不可分割的单词

• 语法分析：将提出的单词连成序列，并根据编程语言规则进行检查，验证其顺序是否合理。

• 语义分析：目的是发现符合语法规定的语句是否具有实际意义。

3. 汇编过程

输入：c/c++

输出：汇编代码

转换成特定cpu指令集的语言集合。经过1、2这两个步骤，可以保证现在的c/c++代码是精简有意义的存在了。那么就可以把它转换成汇编代码了。以gcc编译器为例：

源代码------------->gcc----------->ASCII编码的文本文件

x86处理器体系结构的支持两种指令格式：AT&T intel 格式

4. 优化

输入：汇编代码

输出：汇编代码

最初版本的汇编代码---------->优化------------->最终版汇编代码

优化原则：

• 将寄存器的使用率最小化
• 通过分析能够将预测出实际上不需要执行的部分代码

5. 代码生成阶段

输入：汇编代码

输出：多个二进制文件集合

每一个目标文件对应一个编译单元，汇编指令转成成对应的机器指令（操作码）的二进制值。

ok，这个编译就完成了，在Linux上面，我们可以通过命令查看

gcc -S <input file> -o <output assembler file>.s

程序：

int main()
{
    printf("hello world!");
    return 0;    
}

输入命令：
gcc -S -masm=intel hello.c -o hello.s

输出：

    .file   "hello.c"
    .intel_syntax noprefix
    .section        .rodata
.LC0
    .string "hello world!"
    .text
    .globl  main
    .type   main, @function
main:
.LFB0:
    .cfi_startproc
    push    rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    mov     rbp, rsp
    .cfi_def_cfa_register   6
    mov     edi,  OFFSET FLAT:LC0
    mov     eax, 0
    call    printf
    mov     eax,0
    pop     rbp
    .cfi_def_cfa 7,8
    ret
    .cfi_endproc
.LFE0:
    .size  main, .-main
    .ident "GCC: (Ubuntu  4.8.4.-2ubuntu~14.04.3) 4.8.4"
"hello.s" 28L, 484C

上面输出的就是汇编程序，gcc -c hello.c -o hello.o

--------------------------

1. 符号（symbol）和节（section）是目标文件的基本组成部分，其中符号表示的是程序中的内存地址或数据结构。（这里需要注意，往后我们会非常关注内存地址这个东西）

2. 绝大多数的目标文件中都包含代码节（.text）、初始化数据节（.data）、未初始化数据节（.bss）以及一些特殊节（比如调试信息），这个大家可以对照着看看。

3. 我们的目的是：将编译的每个独立的源代码文件生成的节拼接到一个二进制可执行文件中。

将编译的每个独立的源代码文件生成的节拼接

1. 目标文件中独立的节都有可能包含在最终的程序内存映射中，因为每个目标文件中每个节的起始地址都会被临时设置为0，等待链接时调整，确程序内存映射中每个独立节的实际地址范围。

2. 目标文件中不存在专门的节会影响堆与栈的数据，内存映射中的堆与栈内容完全在程序运行时确定。

以上，将所有目标文件的节集合在一起需要一个标准，需要一个规则，不然怎么集合的完全完整高效呢？这就有了各种平台的规范，比如，可执行文件（exe（win）、EXEC（linux））、静态库（lib（win）、a（linux））、动态库（dll（win）、so（linux））。

那么我们就知道我们应该输入的是什么，输出的又应该是什么

输入：一系列目标文件的集合

输出：规范的二进制文件（可执行文件、静态库、动态库）

1. 重定位

链接过程的第一个阶段紧紧进行拼接，其过程是将分散在单独不表文件中的不同类型的节拼接带程序内u才能映射节中。为了完成该认为有，需要将之前预留的控件，也就是节中从0开始的地址范围转换成最终程序内存映射中更具体的地址范围。 \

2. 解析引用

重定位已经完成地址的线性转成成程序内存映射地址范围。然后我们还得完成一个非常艰巨的任务就是要把各个部分的联系简历起来，使得程序成为一个整体。我们的函数和变量可以分成两种类型，一种是在当前目标文件节中的函数和变量，可以直接通过节中的变对位置就可以寻址成功，而另一种就是在其他目标文件中的函数和变量，我们要做的就是找出那些是这些变量，并找出它的准确地址（内存映射中的地址）。

最后，将机器指令中的伪地址替换成程序内存映射的实际地址，这样我们链接的任务就完成了。

使用linux下的gcc进行示例：

gcc -c function.c main.c           //生成两个目标文件  

gcc function.o main.o -o demoApp     //生成可执行文件

这个就是我们每次编程的时候生成的可执行文件了，是不是很神奇呢？但是需要注意的一点是：

crt0是“纯粹”的入口点，而不是我们通常看到的main函数的入口，它的程序代码的第一部分，在内核控制下执行。

crt1是更为现代化的启动例程（startprountime）,可以在main函数执行前与程序终止后完成一些任务。

装载

程序的执行与物理硬件相关，我们要执行必须要真正地找到那个真实的地址，因为那个地址其实是真实地住着我们的数据和操作指令！我们的可执行文件的地址还不是真正的物理地址，这样他们是找不到那些数据和指令的(带着这问题)。所以，在执行的前期有一个装载的过程。

装载过程

它的最重要的功能就是将链接器创建的节复制带进程内存映射中，它不需要了解各个节的内部结构，它只需要关心是否可读或可读写，以及在可执行问二建启动前是否需要打补丁。

加载过程

当识别出二进制格式以后，内核装载器模块就会派上用场。首先装载器会定位可执行二进制文件中的PT_INTERP段，用于动态加载过程（如果它有的话）。

接着装载器会读取程序的二进制文件段的头，确定每个段的地址和字节长度。需要特别指出的是，在这个阶段装载器仍然不会向内存映射写入任何数据。装载器在此阶段至会建立并维护一组可执行文件段，也就是每个段的页宽，和程序内存映射关联的结构。

在程序启动之后，可执行文件复制段的操作才执行，分配给进程的物理内存页和程序内存映射表之间的虚拟内存关系就已经建立好了。只有在当内核在运行时需要某一个程序段时才会开始加载其对应的页，这种策略使得程序中每一部分只有运行时真正需要时才会加载。

顺便提一下，代码中的传参机制，调用函数我们估计都写不少，但是传参内部机制是什么呢？
就是基于栈的实现机制，比如说，cdecl，stdcall，fastcall，thiscall，每种惯例都是为不同设计视角的特定情况专门设计的（说到这个就有的讲了，我会新开一个篇章来慢慢叙述这个）

编译原理 正式

（看了这么长，其实都是前菜，你说气人不，如果前菜都已经觉得脑子不够用了，那就麻烦下车或者看下去，hhhhhh）

first 预编译

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

例如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)

secord

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文件中都会被调用，那么，我们就只需要在一个文件中定义这个函数，而在其他的文件中声明这个函数就可以了。一个函数还 好对付，声明起来也就一句话。但是，如果函数多了，比如是一大堆的数学函数，有好几百个，那怎么办？能保证每个程序员都可以完完全全地把所有函数的形式都 准确地记下来并写出来吗？

什么是头文件

很显然，答案是不可能。但是有一个很简单地办法，可以帮助程序员们省去记住那么多函数原型的麻烦：我们可以把那几百个函数的声明语句全都先写好，放在一个文件里，等到程序员需要它们的时候，就把这些东西全部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，然后再把这两个目标文件进行链接，程序就可以运行了。

#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"就行了。

头文件中应该写什么

通 过上面的讨论，我们可以了解到，头文件的作用就是被其他的.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文件包含，这个函数成员就被重定义了。

头文件中的保护措施

考虑一下，如果头文件中只包含声明语句的话，它被同一个.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++编译器和链接器的工作原理

（以下不是照着大学那本《编译原理》抄过来的好吧，没这么low的好吧）

首先要搞明白的几个概念：

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

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

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

根据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（根据编译器不同而不同）。

so======>

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文件能使用它。