C/C++ 编译和连接

编译和连接的区别

http://liouwei20051000285.blog.163.com/blog/static/252367420114101014336/
在多道程序环境中，要想将一个用户源代码变成一个可以在内存中执行的程序，通常分为三个步骤：编译、链接、载入。
        （1）编译：由编译程序将用户的源代码编译成若干个目标模块。
       （2）链接：由链接程序将编译后形成的一组目标模块以及它们所需要的库函数链接在一起，形成一个完整的载入模块。
       （3）载入：由载入程序将载入模块载入内存。
 
       编译和链接都是为将用户程序从硬盘上调入内存并将其转换为可执行程序服务的。用编译器时的compile就是在进行编译，link就是链接，运行程序时可以看到。
 
       编译可以理解为高级语言翻译为计算机可以理解的二进制代码，即机器语言。
       链接可以举例解释：一个程序编译后，在作业地址空间中所得到目标模块的起始地址通常是0，假设在1000处有一条指令load 1, 2500，即将2500单元处的数据取至寄存器1中。在多道程序环境下，将程序载入内存时并不可能预先知道所编译的模块应该放在内存的何处。假设程序被载入从10000开始的地址，此时的2500就应该变成了12500，这里就出现问题了，需要修改指令中的相对地址，但此时如果采用动态链接就可以不用修改地址，灵活地解决这个问题了。
       链接分三种：静态链接、载入时动态链接、运行时动态链接，现在流行的是运行时动态链接，这种不仅可以回忆程序的载入过程，而且节省了大量的内存空间。
 
       再来看C/C++的编译和链接：（ 参考第二节Linux下编译C++）
       无论是C/C++，首先要把源文件编译成中间代码文件，在Windows下面就是.obj文件，Unix、Linux下面就是.o文件，即Object File，这个动作叫编译（compile）。然后再把大量的Object File合成执行文件，这个动作叫作链接（link）。
编译时，编译器需要的是语法的正确，函数与变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应该对应于一个中间目标文件（.o文件或是.obj文件）。
链接时，主要是链接函数和全局变量，所以，我们可以使用这些中间目标文件（.o文件或是.obj文件）来链接我们的应用程序。链接器并不管函数所在的源文件，只管函数的中间目标文件（Object File），在大多数时候，由于源文件太多，编译生成的中间目标文件太多，而在链接时需要明显地指出中间目标文件名，这对于编译很不方便，所以，我们要给中间目标文件打个包，在Windows下这种包叫“库文件”（Library File)，也就是 .lib 文件，在UNIX下，是Archive File，也就是.a文件。
总而言之，链接就是那些目标文件之间相互链接自己所需要的函数和全局变量，而函数可能来源于其他目标文件或库文件。

总结一下，源文件首先会生成中间目标文件，再由中间目标文件生成执行文件。在编译时，编译器只检测程序语法，和函数、变量是否被声明。如果函数未被声明，编译器会给出一个警告，但可以生成Object File。而在链接程序时，链接器会在所有的Object File中找寻函数的实现，如果找不到，那到就会报链接错误码（Linker Error），在VC下，这种错误一般是：Link 2001错误，意思说是说，链接器未能找到函数的实现，需要指定函数的Object File。

Linux下 编译C++

转自： http://blog.163.com/dong_box/blog/static/2625977820103310933870/
在编译之前我们需要在系统里安装G++ GCC，它们就是Linux下的C++/C的编译器。代码如下
代码:

sudo apt-get install build-essential
sudo apt-get install gcc
sudo apt-get install g++

好，现在我们在文本编辑器里写一个C的简单的程序（好像所有学习C或者C++的书都会出现）
代码:

＃include <stdio.h>
int main()
{
    printf("Hello,World!\n");
    return 0;
}

现在存盘为Hello.c，打开你的终端，并在文件当前目录输入：
代码:

gcc Hello.c -o hello   

编译时可能会出现如下警告：no newline at and of file ，只有在文件结尾添加一个新行就好了。
然后在终端中输入 ./hello ，你就能在终端中看到程序运行结果了。
下面来说下C++是如何编译的
写程序（不用我多说了吧）
代码:

#include <iostream>
using namespace std;
int main()
{
    cout<<"Hello,World!\n"<<endl;
    return 0;
}

存盘为Hello.cpp
使用gcc编译？？？ 不对，这里我们使用g++来编译C++程序
代码:

g++ Hello.cpp -o hello

编译多个文件我们怎么办？？？ 来看下面出了三个文件Hello.h, Hello.cpp, MyFirst.cpp
代码:

//file_NO1:Hello.h
class Hello {     
public:
      Hello();
     int Display();
};
//file_NO2:Hello.cpp
#include <iostream>
#include "Hello.h"
using namespace std;
Hello::Hello()
{
}
int Hello::Display()
{
    cout<<"Hello,World!\n"<<endl;
     return 0;
}
//file_NO3:MyFirst.cpp
#include <iostream>
#include "Hello.cpp"
int main()
{
    Hello theHello;
    theHello.Display();
    return 0;
}

在g++中有一个参数-c 可以只编译不连接，那么我们就可以按如下顺序编译文件，
代码:

g++ -c Hello.cpp -o Hello.o
g++ -c MyFirst.cpp -o MyFirst.o
g++ MyFirst.o Hello.o -o MyFirst

你是否会问，如果是一个项目的话，可能会有上百个文件，这样的编译法，人不是要累死在电脑前吗，或者等到你编译成功了，岂不是头发都白了，呵呵，所以我们要把上述的编译过程写进以下一个文本文件中：
Linux下称之为 makefile

[code]
#这里可以写一些文件的说明
MyFirst: MyFirst.o hello.o
g++ MyFirst.o hello.o -o MyFirst
Hello.o:Hello.cpp
g++ -c Hello.cpp -o Hello.o
MyFirst.o:MyFirst.cpp
g++ -c MyFirst.cpp -o MyFirst.o
[\code]

存盘为MyFirst，在终端输入：make MyFist ，程序出现了错误可是所有程序员共同的敌人，在编写程序时我们应该尽量的去避免错误的出现，不过编写的时候再怎么都不可避免的出现这样那样的错误，对程序进行必要的调试是一个好主意，那我们怎么来调试程序呢，看下面：

[code]
gdb ./文件名
[/code]
以下为调试状态下的可以用到的命令（可以仅输入单词的输入，如break可简为b），尖括号中为说明
[code]
list <显示源代码>
break 行号 <设置断点>
run <运行程序>
continue <继续从断点处执行>
print 变量 <调试时查看变量的值>
del 行号 <删除断点>
step <单步执行，可跟踪到函数内部>
next <单步执行，不可跟踪到函数内部>
quit <退出>
[/code]

C++编译器与链接器工作原理

转自： http://blog.csdn.net/success041000/article/details/6714195

1. 几个概念
    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文件。
2. 分析编译的过程
     源文件：A.cpp
     int n = 1;
     void FunA() {
         ++n;
     }
     目标文件：A.obj
     偏移量     内容     长度
     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
    A.obj的未解决符号表
   为空（因为它没有引用别的编译单元里的东西）
    B.obj的导出符号表
    符号             地址
    _FunB        0x0000
    B.obj的未解决符号表
    符号             地址
    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。
3. 总结一下：
     目标文件至少要提供三个表：未解决符号表，导出符号表和地址重定向表。
     (1)未解决符号表：列出了本单元里有引用但是不在本单元定义的符号及其出现的地址。
     (2)导出符号表：提供了本编译单元具有定义，并且可以提供给其他编译单元使用的符号及其在本单元中的地址。
     (3)地址重定向表：提供了本编译单元所有对自身地址的引用记录。 
      链接器的工作顺序：
      当链接器进行链接的时候，首先决定各个目标文件在最终可执行文件里的位置。然后访问所有目标文件的地址重定义表，对其中记录的地址进行重定向（加上一个偏移量，即该编译单元在可执行文件上的起始地址）。然后遍历所有目标文件的未解决符号表，并且在所有的导出符号表里查找匹配的符号，并在未解决符号表中所记录的位置上填写实现地址。最后把所有的目标文件的内容写在各自的位置上，再作一些另的工作，就生成一个可执行文件。
      说明：实现链接的时候会更加复杂，一般实现的目标文件都会把数据，代码分成好向个区，重定向按区进行，但原理都是一样的。明白了编译器与链接器的工作原理后，对于一些链接错误就容易解决了。
4. 下面再看一看C/C++中提供的一些特性
     extern：这就是告诉编译器，这个变量或函数在别的编译单元里定义了，也就是要把这个符号放到未解决符号表里面去（外部链接）。
     static：如果该关键字位于全局函数或者变量的声明前面，表明该编译单元不导出这个函数或变量，因些这个符号不能在别的编译单元中使用（内部链接）。如果是static局部变量，则该变量的存储方式和全局变量一样，但是仍然不导出符号。 
     默认链接属性：对于函数和变量，默认链接是外部链接，对于const变量，默认内部链接。
     外部链接的利弊：外部链接的符号在整个程序范围内都是可以使用的，这就要求其他编译单元不能导出相同的符号（不然就会报
duplicated external symbols）。
     内部链接的利弊：内部链接的符号不能在别的编译单元中使用。但不同的编译单元可以拥有同样的名称的符号。
     为什么头文件里一般只可以有声明不能有定义：头文件可以被多个编译单元包含，如果头文件里面有定义的话，那么每个包含这头文件的编译单元都会对同一个符号进行定义，如果该符号为外部链接，则会导致duplicated external symbols链接错误。 
     为什么公共使用的内联函数要定义于头文件里：因为编译时编译单元之间互不知道，如果内联被定义于.cpp文件中，编译其他使用该函数的编译单元的时候没有办法找到函数的定义，因些无法对函数进行展开。所以如果内联函数定义于.cpp里，那么就只有这个.cpp文件能使用它。