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

模版的编译

C++ 模板类的声明与实现分离问题_第1张图片

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

你可能感兴趣的:(c++,c++,开发语言)