C++ 模板类的声明与实现分离问题

模版的编译

c++ primer

• 一般来说，如果你的项目没有混合使用 C 和 C++ 语言，那么你使用 .h 和 .cpp 是没有问题的。否则你将C和C++的头文件进行分离,因为通常我们把C和C++分离编译，再统一链接;
• 函数经过编译系统的翻译成汇编，函数名对应着汇编标号。 因为C编译函数名与得到的汇编代号基本一样，如：fun()=>_fun, main=>_main ；但是C++中函数名与得到的汇编代号有比较大的差别。 如：由于函数重载，函数名一样，但汇编代号绝对不能一样。
• 为了区分，编译器会把函数名和参数类型合在一起作为汇编代号， 这样就解决了重载问题。具体如何把函数名和参数类型合在一起， 要看编译器的帮助说明了。
• 这样一来，如果C++调用C，如fun(),则调用名就不是C的翻译结果_fun, 而是带有参数信息的一个名字，因此就不能调用到fun（），为了解决 这个问题，加上extern "C"表示该函数的调用规则是C的规则，则调用 时就不使用C++规则的带有参数信息的名字，而是_fun,从而达到调用 C函数的目的。
  具体看下面的栗子：

//test.h
#ifndef ALGORITHMS_TEST_H
#define ALGORITHMS_TEST_H

template 
class Foo
{
    T bar;
public:
    //void doSomething(T param) {/* do stuff using T */}
    void doSomething(T param);
};


#endif //ALGORITHMS_TEST_H
//test.cpp
#include
#include "test.h"

template 
void  Foo::doSomething(T param) {
    std::cout << param << std::endl;
}
//main.cpp
#include "test.h"
int main() {
    Foo f;
    f.doSomething(3);
    return 0;
}

编译报连接错误

ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make[3]: *** [Algorithms] Error 1

为什么模版类的声明和实现分开会出现连接问题呢

因为需要单独编译，并且模板是实例化样式的多态性；
在实例化模板时，编译器会使用给定的模板参数创建一个新类。例如：

template
struct Foo
{
    T bar;
    void doSomething(T param) {/* do stuff using T */}
};

// somewhere in a .cpp
Foo f; 

阅读此行时，编译器将创建一个新类（我们称之为FooInt），其等效于以下内容：

struct FooInt
{
    int bar;
    void doSomething(int param) {/* do stuff using int */}
}

因此，编译器需要访问方法的实现，以使用template参数实例化它们（在这种情况下为int）。如果这些实现不在头文件中，则将无法访问它们，因此编译器将无法实例化模板。

具体解释如下：

foo.h
    声明的接口 class MyClass
foo.cpp
    定义执行 class MyClass
bar.cpp
    用途 MyClass

• 单独编译意味着我应该能够独立于bar.cpp编译foo.cpp。编译器在每个编译单元上完全独立地完成分析、优化和代码生成的所有艰苦工作;我们不需要做整个程序分析。只有链接器需要一次处理整个程序，链接器的工作大大简化了。
• 当我编译foo.cpp时，bar.cpp甚至不需要存在，但是我仍然应该可以将foo.o与bar.o一起使用。刚刚生成的文件，而无需重新编译foo.cpp。甚至可以将foo.cpp编译成动态库，而无需foo.cpp即可将其分发到其他位置，并与在我编写foo.cpp之后多年编写的代码链接。
• "实例化样式多态性”表示模板MyClass并不是真正的通用(范型)类，它不能被编译成可以处理任何T值的代码。这将增加开销，如装箱，需要传递函数指针到分配器和构造器，等等。c++模板的目的是避免编写几乎相同的类MyClass_int、类MyClass_float等，但仍然能够编译代码，结束了就像我们分别编写每个版本一样。因此，模板实际上是模板。类模板不是类，而是为T我们遇到的每个类创建新类的秘诀。模板不能被编译成代码，只有实例化模板的结果可以被译。
• 因此，在编译foo.cpp时，编译器无法通过看到bar.cpp来知道需要MyClass。它可以看到模板MyClass，但不能为此编译出相应的代码（它是模板，而不是类）。并且在编译bar.cpp时，编译器可以看到它需要创建一个MyClass，但是看不到该模板MyClass（只能在foo.h中看到其接口，不能看到具体类成员函数的具体实现等），因此无法创建它。
• 如果Foo.cpp中本身使用MyClass，将在编译时会产生对应代码在Foo.cpp中，因此当文件bar.o链接到文件foo.o他们可以连接并工作。我们可以利用这一事实，通过编写单个模板，在.cpp文件中实现一组有限的模板实例化。但bar.cpp无法将模板作为模板实例化它的类型;它只能使用foo.cpp的作者认为提供的模板化类的已存在版本。
• 您可能会认为，在编译模板时，编译器应“生成所有版本”，并且在链接过程中会滤除从未使用过的版本。除了庞大的开销和极端的困难之外，这种方法还会面临困难，因为指针和数组之类的“类型修饰符”功能甚至允许内置类型产生无限数量的类型，当我现在扩展程序时会发生什么通过添加:

baz.cpp
    声明并实现class BazPrivate，并使用MyClass

除非我们：

• 1、每当我们改变程序中的任何其他文件时，必须重新编译foo.cpp，以防它添加了一个新的实例化MyClass
• 2、要求baz.cpp包含（可能通过标头包含）的完整模板MyClass，以便编译器可以MyClass在编译baz.cpp时生成。
  没有人喜欢(1)，因为整个程序分析的编译系统需要很长时间来编译，而且如果没有源代码，就不可能分发已编译的库。所以我们用(2)代替。

解决方案

• 常见的解决方案是将模板声明写入头文件中，然后在实现文件中实现该类（例如.tpp），并在头末尾包含该实现文件。

//test.h
template 
struct Foo
{
    void doSomething(T param);
};

#include "test.tpp"

//test.tpp
template 
void Foo::doSomething(T param)
{
    //implementation
}

这样，实现仍与声明分开，但编译器可以访问;

• 另外一种代替的解决方案：使实现分离，并显式实例化所需的所有模板实例：

//Foo.h
//no implementation
//template  struct Foo { ... };
template 
class Foo
{
    T bar;
public:
    //void doSomething(T param) {/* do stuff using T */}
    void doSomething(T param);
};

//Foo.cpp
// implementation of Foo's methods
// explicit instantiations

template 
void  Foo::doSomething(T param) {
    std::cout << param << std::endl;
}

template class Foo;  //相关的实例化代码由编译器产生
template class Foo;
//main.cpp
#include "test.hpp"
int main(int argc, const char * argv[]) {   
 
    Foo f;
    f.doSomething(3);
    
    return 0;
    
}

/* 编译运行成功：
    3  Program ended with exit code: 0
*/

转载自：https://www.jianshu.com/p/bd2e05aabf7a
参考：https://stackoverflow.com/questions/495021/why-can-templates-only-be-implemented-in-the-header-file