为何C++编译器不能支持对模板的分离式编译

今天在写队列模板类的时候，我把模板类的声明与实现分开写后，在测试的.cpp文件编译时报错“未定义的引用....."

在网上查阅得知缘由是：c++编译器不支持对模板的分离式编译

 

首先，一个编译单元（translation unit）是指一个.cpp文件以及它所#include的全部.h文件，.h文件里的代码将会被扩展到包含它的.cpp文件里，而后编译器编译该.cpp文件为一个.obj文件（假定咱们的平台是win32），后者拥有PE（Portable Executable，即windows可执行文件）文件格式，而且自己包含的就已是二进制码，可是不必定可以执行，由于并不保证其中必定有main函数。当编译器将一个工程里的全部.cpp文件以分离的方式编译完毕后，再由链接器（linker）进行链接成为一个.exe文件。

 

举个例子：

 

//---------------test.h-------------------//

void f();//这里声明一个函数f

 

//---------------test.cpp--------------//

#include”test.h”

void f()

{

…//do something

}  //这里实现出test.h中声明的f函数

 

//---------------main.cpp--------------//

#include”test.h”

int main()

{

f(); //调用f，f具备外部链接类型

}

 

在这个例子中，test. cpp和main.cpp各自被编译成不一样的.obj文件（姑且命名为test.obj和main.obj），在main.cpp中，调用了f函数，然而当编译器编译main.cpp时，它所仅仅知道的只是main.cpp中所包含的test.h文件中的一个关于void f();的声明，因此，编译器将这里的f看做外部链接类型，即认为它的函数实现代码在另外一个.obj文件中，本例也就是test.obj，也就是说，main.obj中实际没有关于f函数的哪怕一行二进制代码，而这些代码实际存在于test.cpp所编译成的test.obj中。在main.obj中对f的调用只会生成一行call指令，像这样：

 

call f [C++中这个名字固然是通过mangling[处理]过的]

 

在编译时，这个call指令显然是错误的，由于main.obj中并没有一行f的实现代码。那怎么办呢？这就是链接器的任务，链接器负责在其它的.obj中（本例为test.obj）寻找f的实现代码，找到之后将call f这个指令的调用地址换成实际的f的函数进入点地址。须要注意的是：链接器实际上将工程里的.obj“链接”成了一个.exe文件，而它最关键的任务就是上面说的，寻找一个外部链接符号在另外一个.obj中的地址，而后替换原来的“虚假”地址。

 

这个过程若是说的更深刻就是：

 

call f这行指令其实并非这样的，它其实是所谓的stub，也就是一个jmp 0xABCDEF。这个地址多是任意的，然而关键是这个地址上有一行指令来进行真正的call f动做。也就是说，这个.obj文件里面全部对f的调用都jmp向同一个地址，在后者那儿才真正”call”f。这样作的好处就是链接器修改地址时只要对后者的call XXX地址做改动就好了。可是，链接器是如何找到f的实际地址的呢（在本例中这处于test.obj中），由于.obj与.exe的格式是同样的，在这样的文件中有一个符号导入表和符号导出表（import table和export table）其中将全部符号和它们的地址关联起来。这样链接器只要在test.obj的符号导出表中寻找符号f（固然C++对f做了mangling）的地址就好了，而后做一些偏移量处理后（由于是将两个.obj文件合并，固然地址会有必定的偏移，这个链接器清楚）写入main.obj中的符号导入表中f所占有的那一项便可。

 

这就是大概的过程。其中关键就是：

 

编译main.cpp时，编译器不知道f的实现，因此当碰到对它的调用时只是给出一个指示，指示链接器应该为它寻找f的实现体。这也就是说main.obj中没有关于f的任何一行二进制代码。

 

编译test.cpp时，编译器找到了f的实现。因而乎f的实现（二进制代码）出如今test.obj里。

 

链接时，链接器在test.obj中找到f的实现代码（二进制）的地址（经过符号导出表）。而后将main.obj中悬而未决的call XXX地址改为f实际的地址。完成。

 

然而，对于模板，你知道，模板函数的代码其实并不能直接编译成二进制代码，其中要有一个“实例化”的过程。举个例子：

 

//----------main.cpp------//

template<class T>

void f(T t)

{}

 

int main()

{

…//do something

f(10); // call f<int> 编译器在这里决定给f一个f<int>的实例

…//do other thing

}

 

也就是说，若是你在main.cpp文件中没有调用过f，f也就得不到实例化，从而main.obj中也就没有关于f的任意一行二进制代码！若是你这样调用了：

 

f(10); // f<int>得以实例化出来

f(10.0); // f<double>得以实例化出来

 

这样main.obj中也就有了f<int>，f<double>两个函数的二进制代码段。以此类推。

 

然而实例化要求编译器知道模板的定义，不是吗？

 

看下面的例子（将模板的声明和实现分离）：

 

//-------------test.h----------------//

template<class T>

class A

{

public:

void f(); // 这里只是个声明

};

 

//---------------test.cpp-------------//

#include”test.h”

template<class T>

void A<T>::f()  // 模板的实现

{

   …//do something

}

 

//---------------main.cpp---------------//

#include”test.h”

int main()

{

A<int> a;

f(); // #1

}

 

编译器在#1处并不知道A<int>::f的定义，由于它不在test.h里面，因而编译器只好寄但愿于链接器，但愿它可以在其余.obj里面找到A<int>::f的实例，在本例中就是test.obj，然而，后者中真有A<int>::f的二进制代码吗？NO！！！由于C++标准明确表示，当一个模板不被用到的时侯它就不应被实例化出来，test.cpp中用到了A<int>::f了吗？没有！！因此实际上test.cpp编译出来的test.obj文件中关于A::f一行二进制代码也没有，因而链接器就傻眼了，只好给出一个链接错误。可是，若是在test.cpp中写一个函数，其中调用A<int>::f，则编译器会将其实例化出来，由于在这个点上（test.cpp中），编译器知道模板的定义，因此可以实例化，因而，test.obj的符号导出表中就有了A<int>::f这个符号的地址，因而链接器就可以完成任务。

 

关键是：在分离式编译的环境下，编译器编译某一个.cpp文件时并不知道另外一个.cpp文件的存在，也不会去查找（当遇到未决符号时它会寄但愿于链接器）。这种模式在没有模板的状况下运行良好，但遇到模板时就傻眼了，由于模板仅在须要的时候才会实例化出来，因此，当编译器只看到模板的声明时，它不能实例化该模板，只能建立一个具备外部链接的符号并期待链接器可以将符号的地址决议出来。然而当实现该模板的.cpp文件中没有用到模板的实例时，编译器懒得去实例化，因此，整个工程的.obj中就找不到一行模板实例的二进制代码，因而链接器也黔驴技穷了。

 

转自：http://blog.csdn.net/pongba/article/details/19130