将模板化的C ++类拆分为.hpp / .cpp文件-有可能吗？

我在尝试编译在.hpp和.cpp文件之间分割的C ++模板类时遇到错误：

$ g++ -c -o main.o main.cpp  
$ g++ -c -o stack.o stack.cpp   
$ g++ -o main main.o stack.o  
main.o: In function `main':  
main.cpp:(.text+0xe): undefined reference to 'stack<int>::stack()'  
main.cpp:(.text+0x1c): undefined reference to 'stack<int>::~stack()'  
collect2: ld returned 1 exit status  
make: *** [program] Error 1  

这是我的代码：

stack.hpp：

#ifndef _STACK_HPP
#define _STACK_HPP

template <typename Type>
class stack {
    public:
            stack();
            ~stack();
};
#endif

stack.cpp：

#include <iostream>
#include "stack.hpp"

template <typename Type> stack<Type>::stack() {
        std::cerr << "Hello, stack " << this << "!" << std::endl;
}

template <typename Type> stack<Type>::~stack() {
        std::cerr << "Goodbye, stack " << this << "." << std::endl;
}

main.cpp：

#include "stack.hpp"

int main() {
    stack<int> s;

    return 0;
}

ld当然是正确的：符号不在中stack.o。

这个问题的答案无济于事，正如我所说的那样。
这可能会有所帮助，但是我不想将每个方法都移动到.hpp文件中，我不必，应该吗？

将.cpp文件中的所有内容移动到.hpp文件中并仅包含所有内容而不是将其作为独立目标文件链接的唯一合理解决方案吗？这似乎非常难看！在这种情况下，我还不如恢复到我以前的状态，并重新命名stack.cpp，以stack.hpp和与它做。

无法在单独的cpp文件中编写模板类的实现并进行编译。如果有人声称，这样做的所有方法都是模仿单独cpp文件使用的解决方法，但是实际上，如果您打算编写模板类库并将其与标头和lib文件一起分发以隐藏实现，则根本不可能。

要知道为什么，让我们看一下编译过程。头文件从不编译。它们仅经过预处理。然后将预处理的代码与实际编译的cpp文件合并。现在，如果编译器必须为对象生成适当的内存布局，则它需要知道模板类的数据类型。

实际上，必须理解，模板类根本不是一个类，而是一个类的模板，该类的声明和定义由编译器在从参数获取数据类型的信息后在编译时生成。只要无法创建内存布局，就无法生成方法定义的指令。请记住，类方法的第一个参数是“ this”运算符。所有类方法都将转换为具有名称修饰和第一个参数作为其操作对象的单个方法。“ this”参数实际上是关于对象的大小的信息，除非用户使用有效的类型参数实例化对象，否则在编译器无法使用模板类的情况下。在这种情况下，如果将方法定义放在单独的cpp文件中并尝试对其进行编译，则不会使用类信息生成目标文件本身。编译不会失败，它将生成目标文件，但不会为目标文件中的模板类生成任何代码。这就是链接器无法在目标文件中找到符号且构建失败的原因。

现在，隐藏重要实施细节的替代方法是什么？众所周知，从实现中分离接口的主要目的是以二进制形式隐藏实现细节。这是您必须分离数据结构和算法的地方。模板类必须仅代表数据结构，而不代表算法。这使您可以在单独的非模板化类库中隐藏更有价值的实现细节，其中的类将在模板类上工作或仅使用它们来保存数据。模板类实际上包含较少的代码来分配，获取和设置数据。其余工作将由算法类完成。

我希望这个讨论会有所帮助。

这是可能的，只要你知道实例，你将需要。

在stack.cpp的末尾添加以下代码，它将起作用：

template class stack<int>;

所有非模板堆栈方法都将被实例化，并且链接步骤将正常工作。

你可以这样

// xyz.h
#ifndef _XYZ_
#define _XYZ_

template <typename XYZTYPE>
class XYZ {
  //Class members declaration
};

#include "xyz.cpp"
#endif

//xyz.cpp
#ifdef _XYZ_
//Class definition goes here

#endif

这已在Daniweb中讨论过

也在FAQ中，但使用C ++ export关键字。

不，不可能。并非没有export关键字，对于所有意图和目的而言，关键字实际上都不存在。

最好的办法是将函数实现放在“ .tcc”或“ .tpp”文件中，并在.hpp文件末尾#include .tcc文件。但是，这仅仅是装饰性的；它仍然与在头文件中实施所有操作相同。这只是您使用模板所要付出的代价。

我相信将模板代码分为标头和cpp的主要原因有两个：

一个是纯粹的优雅。我们所有人都喜欢编写浪费时间阅读，管理并在以后可重用的代码。

其他是减少编译时间。

我目前（一如既往）正在与OpenCL结合使用来编码仿真软件，我们希望保留代码，以便可以根据硬件功能根据需要使用float（cl_float）或double（cl_double）类型运行它。现在，这是在代码开头使用#define REAL来完成的，但这不是很优雅。更改所需的精度需要重新编译应用程序。由于没有真正的运行时类型，因此我们暂时必须使用它。幸运的是，OpenCL内核是经过编译的运行时，而简单的sizeof（REAL）允许我们相应地更改内核代码的运行时。

更大的问题是，即使应用程序是模块化的，在开发辅助类（例如那些预先计算模拟常数的类）时也必须进行模板化。这些类都至少在类依赖树的顶部至少出现一次，因为最终的模板类Simulation将具有这些工厂类之一的实例，这意味着实际上每次我对工厂类进行较小的更改时，整个软件必须重建。这很烦人，但我似乎找不到更好的解决方案。

仅当您#include "stack.cpp在stack.hpp。如果实现比较大，并且将.cpp文件重命名为另一个扩展名，以区别于常规代码，我只会推荐这种方法。

如果可以将所有模板参数的通用功能foo提取到非模板类中（有时可能是类型不安全的），则有时可以将大部分实现隐藏在cpp文件中。然后，标头将包含对该类的重定向调用。解决“模板膨胀”问题时，使用了类似的方法。

如果您知道将使用哪种类型的堆栈，则可以在cpp文件中显式实例化它们，并将所有相关的代码保存在那里。

也可以跨DLL（！）导出这些文件，但是正确获取语法（__declspec（dllexport）和export关键字的MS特定组合）非常棘手。

我们已经在以double / float为模板的math / geom库中使用了它，但是有很多代码。（我当时在Google上搜索，但是今天没有该代码。）

问题在于模板不会生成实际的类，而只是告诉编译器如何生成类的模板。您需要生成一个具体的类。

一种简单自然的方法是将这些方法放在头文件中。但是还有另一种方式。

在.cpp文件中，如果您引用了所需的每个模板实例化和方法，则编译器将在其中生成它们以供整个项目使用。

新的stack.cpp：

#include <iostream>
#include "stack.hpp"
template <typename Type> stack<Type>::stack() {
        std::cerr << "Hello, stack " << this << "!" << std::endl;
}
template <typename Type> stack<Type>::~stack() {
        std::cerr << "Goodbye, stack " << this << "." << std::endl;
}
static void DummyFunc() {
    static stack<int> stack_int;  // generates the constructor and destructor code
    // ... any other method invocations need to go here to produce the method code
}

您需要将所有内容都放在hpp文件中。问题在于，直到编译器发现某个其他cpp文件需要它们之后才真正创建这些类-因此它当时必须具有所有可用代码来编译模板化类。

我倾向于做的一件事是尝试将模板拆分为通用的非模板部分（可以在cpp / hpp之间拆分）和继承非模板类​​的特定于类型的模板部分。

由于模板是在需要时编译的，因此对多文件项目施加了限制：模板类或函数的实现（定义）必须与声明的文件位于同一文件中。这意味着我们不能在单独的头文件中分隔接口，并且必须在使用模板的任何文件中同时包含接口和实现。

另一种可能性是做类似的事情：

#ifndef _STACK_HPP
#define _STACK_HPP

template <typename Type>
class stack {
    public:
            stack();
            ~stack();
};

#include "stack.cpp"  // Note the include.  The inclusion
                      // of stack.h in stack.cpp must be 
                      // removed to avoid a circular include.

#endif

我不喜欢这个建议，但它可能适合您。

关键字'export'是从模板声明中分离出模板实现的方法。这是在C ++标准中引入的，没有现有的实现。在适当的时候，只有几个编译器实际实现了它。在有关出口的Inform IT文章上阅读详细信息

1）记住分离.h和.cpp文件的主要原因是将类实现隐藏为单独编译的Obj代码，该代码可以链接到包含该类.h的用户代码。

2）非模板类具有在.h和.cpp文件中具体定义的所有变量。因此，在编译/翻译生成对象/机器代码之前，编译器将具有有关该类中使用的所有数据类型的需求信息。在类的用户实例化传递所需数据的对象之前，模板类不具有有关特定数据类型的信息。类型：

        TClass<int> myObj;

3）仅在实例化之后，编译器才会生成模板类的特定版本以匹配传递的数据类型。

4）因此，.cpp在不知道用户特定数据类型的情况下不能单独编译。因此，它必须作为源代码保留在“ .h”中，直到用户指定所需的数据类型，然后才能将其生成为特定的数据类型，然后进行编译

我正在使用Visual Studio 2010，如果您想将文件拆分为.h和.cpp，请在.h文件末尾包含cpp标头