使用外部模板 (C++11)

您应该只使用 extern template 来强制编译器不在 您知道将在其他地方实例化模板时实例化它。它用于减少编译时间和目标文件大小。

例如：

// header.h

template<typename T>
void ReallyBigFunction()
{
    // Body
}

// source1.cpp

#include "header.h"
void something1()
{
    ReallyBigFunction<int>();
}

// source2.cpp

#include "header.h"
void something2()
{
    ReallyBigFunction<int>();
}

这将产生以下目标文件：

source1.o
    void something1()
    void ReallyBigFunction<int>()    // Compiled first time

source2.o
    void something2()
    void ReallyBigFunction<int>()    // Compiled second time

如果两个文件链接在一起，一个 void ReallyBigFunction<int>() 将被丢弃，从而导致编译时间和目标文件大小的浪费。

为了不浪费编译时间和目标文件大小，有一个 extern 关键字使编译器不编译模板函数。你应该使用这个当且仅当你知道它在其他地方的同一个二进制文件中使用。

将 source2.cpp 更改为：

// source2.cpp

#include "header.h"
extern template void ReallyBigFunction<int>();
void something2()
{
    ReallyBigFunction<int>();
}

将产生以下目标文件：

source1.o
    void something1()
    void ReallyBigFunction<int>() // compiled just one time

source2.o
    void something2()
    // No ReallyBigFunction<int> here because of the extern

当这两个链接在一起时，第二个目标文件将只使用第一个目标文件中的符号。无需丢弃，也不会浪费编译时间和目标文件大小。

这应该只在一个项目中使用，例如当您多次使用像 vector<int> 这样的模板时，您应该在除一个源文件之外的所有文件中使用 extern。

这也适用于类和函数合一，甚至模板成员函数。

---

维基百科有 best description

在 C++03 中，只要在翻译单元中遇到完全指定的模板，编译器就必须实例化模板。如果模板在许多翻译单元中使用相同的类型进行实例化，则会显着增加编译时间。在 C++03 中没有办法阻止这种情况，因此 C++11 引入了外部模板声明，类似于外部数据声明。 C++03 有这样的语法来强制编译器实例化一个模板：模板类 std::vector; C++11 现在提供这种语法：extern template class std::vector;它告诉编译器不要在这个翻译单元中实例化模板。

警告：使用了非标准扩展...

Microsoft VC++ 曾经有一个 non-standard version of this feature 已经有几年了（在 C++03 中）。编译器会对此发出警告，以防止需要在不同编译器上编译的代码出现可移植性问题。

查看 linked page 中的示例，看看它的工作方式大致相同。您可以预期该消息会随着 MSVC 的未来版本消失，当然，同时使用 other 非标准编译器扩展时除外。

---

仅当模板声明完整时才需要extern template

这在其他答案中有所暗示，但我认为没有给予足够的重视。

这意味着在 OP 的示例中，extern template 无效，因为标头上的模板定义不完整：

void f();: 只是声明，没有正文

foo 类：声明了方法 f() 但没有定义

所以我建议在这种特殊情况下只删除 extern template 定义：如果类已完全定义，您只需要添加它们。

例如：

模板头文件.h

template<typename T>
void f();

模板Cpp.cpp

template<typename T>
void f(){}

// Explicit instantiation for char.
template void f<char>();

主文件

#include "TemplHeader.h"

// Commented out from OP code, has no effect.
// extern template void f<T>(); //is this correct?

int main() {
    f<char>();
    return 0;
}

使用 nm 编译和查看符号：

g++ -std=c++11 -Wall -Wextra -pedantic -c -o TemplCpp.o TemplCpp.cpp
g++ -std=c++11 -Wall -Wextra -pedantic -c -o Main.o Main.cpp
g++ -std=c++11 -Wall -Wextra -pedantic -o Main.out Main.o TemplCpp.o
echo TemplCpp.o
nm -C TemplCpp.o | grep f
echo Main.o
nm -C Main.o | grep f

输出：

TemplCpp.o
0000000000000000 W void f<char>()
Main.o
                 U void f<char>()

然后从 man nm 我们看到 U 表示未定义，因此定义确实只保留在 TemplCpp 上。

所有这一切都归结为完整标头声明的权衡：

优点：允许外部代码将我们的模板与新类型一起使用，如果我们对对象膨胀没问题，我们可以选择不添加显式实例化

允许外部代码将我们的模板与新类型一起使用

如果我们对对象膨胀没问题，我们可以选择不添加显式实例化

缺点：在开发该类时，头文件实现更改将导致智能构建系统重新构建所有包含器，如果我们想避免目标文件膨胀，这可能是很多很多文件，我们不仅需要进行显式实例化（与不完整的头文件声明相同） ) 还要在每个包含器上添加外部模板，程序员可能会忘记这样做

在开发该类时，标头实现更改将导致智能构建系统重新构建所有包含器，这可能是许多文件

如果我们想避免目标文件膨胀，我们不仅需要进行显式实例化（与不完整的标头声明相同），还要在每个包含器上添加 extern 模板，程序员可能会忘记这样做

更多示例显示在：Explicit template instantiation - when is it used?

由于编译时间在大型项目中非常重要，我强烈建议使用不完整的模板声明，除非外部方绝对需要使用他们自己的复杂自定义类重用您的代码。

在这种情况下，我会首先尝试使用多态性来避免构建时间问题，并且仅在可以获得显着性能提升的情况下使用模板。

在 Ubuntu 18.04 中测试。

---

模板的已知问题是代码膨胀，这是在调用类模板专业化的每个模块中生成类定义的结果。为了防止这种情况，从 C++0x 开始，可以在类模板特化前使用关键字 extern

#include <MyClass>
extern template class CMyClass<int>;

模板类的显式实例应该只发生在单个翻译单元中，最好是带有模板定义（MyClass.cpp）的翻译单元

template class CMyClass<int>;
template class CMyClass<float>;

---

如果您以前使用过 extern 作为函数，则模板遵循完全相同的理念。如果没有，通过 extern 进行简单的功能可能会有所帮助。此外，您可能希望将 extern(s) 放在头文件中，并在需要时包含头文件。

---