C++ 模板类的声明和定义都要放在 .h （头）文件中的原因

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

例如：

\\ ------- in Test.h start
#ifndef TEST_H
#define TEST_H

void testOutput();

#endif // TEST_H
\\ ------- in Test.h end

\\ ------- in Test.cpp start
#include "Test.h"
#include 

void testOutput()
{
    qDebug() << "This is a test output.";
}
\\ ------- in Test.cpp end

\\ ------- in main.cpp start
#include 
#include "ZDS/Test.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    testOutput();

    return a.exec();
}
\\ ------- in main.cpp end

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

call testOutput // 这里假设假设叫 testOutput

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

这个过程如果说的更深入就是：

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

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

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

2. 编译 Test.cpp 时，编译器找到了 testOutput 的实现。于是乎f的实现（二进制代码）出现在 Test.obj里。

3. 连接时，连接器在 Test.obj 中找到f的实现代码（二进制）的地址（通过符号导出表）。然后将 main.obj 中[悬而未决]的 call XXX 地址改成 testOutput 实际的地址。完成。

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

\\ ------- in Test.h start
#ifndef TEST_H
#define TEST_H
#include 

template
void testOutput(T test) {
    qDebug() << "This is a test output: " << test;
}

#endif // TEST_H
\\ ------- in Test.h end

\\ ------- in main.h start
#include 
#include "ZDS/Test.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    testOutput("haha");

    return a.exec();
}
\\ ------- in main.h end

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

f(10); // f得以实例化出来
f(10.0); // f得以实例化出来

这样 main.obj 中也就有了 testOutput，testOutput 两个函数的二进制代码段。[以此类推]

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

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

\\ ------- in Test.h start
#ifndef TEST_H
#define TEST_H

template 
class Test
{
public:
    Test(T v)
        : t (v)
    {}

    void testOutput();

private:
    T t;
};

#endif // TEST_H
\\ ------- in Test.h end

\\ ------- in Test.cpp start
#include "Test.h"
#include 

template
void Test::testOutput()
{
    qDebug() << "This is a test output: " << t;
}
\\ ------- in Test.cpp end

\\ ------- in main.cpp start
#include 
#include "ZDS/Test.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Test test(13);
    test.testOutput(); // #1

    return a.exec();
}
\\ ------- in main.cpp end

此时，运行的话，会提示：

main.obj:-1: error: LNK2019: 无法解析的外部符号 "public: void __thiscall Test::testOutput(void)" (?testOutput@?$Test@H@@QAEXXZ)，该符号在函数 _main 中被引用

编译器在#1处并不知道 Test::testOutput 的定义，因为它不在 Test.h 里面，于是编译器只好寄希望于连接器，希望它能够在其他 .obj 里面找到 Test::testOutput 的实例，在本例中就是 Test.obj，然而，后者中真有 Test::testOutput 的二进制代码吗？NO！！！因为 C++ 标准明确表示，当一个模板不被用到的时侯它就不该被实例化出来，Test.cpp 中用到了 Test::testOutput 了吗？没有！！所以实际上 Test.cpp 编译出来的 Test.obj 文件中关于 Test::testOutput 一行二进制代码也没有，于是连接器就傻眼了，只好给出一个连接错误。但是，如果在 Test.cpp 中写一个函数，使其调用 Test::testOutput，则编译器会将其实例化出来，因为在（Test.cpp 中的）这个点上，编译器知道模板的定义，所以能够实例化，于是，Test.obj 的符号导出表中就有了 Test::testOutput 这个符号的地址，于是连接器就能够完成任务。

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

所以，目前我们必须要将 C++ 模板类的声明和定义都要放在.h文件中：

\\ ------- in Test.h start
#ifndef TEST_H
#define TEST_H

#include 

template 
class Test
{
public:
    Test(T v)
        : t (v)
    {}

    void testOutput();

private:
    T t;
};

template
void Test::testOutput()
{
    qDebug() << "This is a test output: " << t;
}

#endif // TEST_H
\\ ------- in Test.h end

\\ ------- in main.cpp start
#include 
#include "ZDS/Test.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Test test(13);
    test.testOutput(); // #2

    return a.exec();
}
\\ ------- in main.cpp end

此时，上述代码才能够顺利运行。

注：本文参考自《c++ 模板类声明和定义都放在.h文件的原因》

C++ 模板类的声明和定义都要放在 .h （头）文件中的原因

你可能感兴趣的:(C++ 模板类的声明和定义都要放在 .h （头）文件中的原因)