C++11 外部模板

【1】引入外部模板为了解决什么问题？

“外部模板”是C++11中一个关于模板性能上的改进。实际上，“外部”（extern）这个概念早在C的时候已经就有了。

常见的情况，在一个文件a.c中定义了一个变量int i，而在另外一个文件b.c中想使用它，这个时候就会在没有定义变量i的b.c文件中做一个外部变量的声明。比如：

// 声明在b.c文件中
extern int i;

这样做的好处是，在分别编译了a.c和b.c之后，其生成的目标文件a.o和b.o中只有i这个符号（可简单理解为变量）的一份定义。

具体地，a.o中的i是实在存在于a.o目标文件的数据区中的数据，而在b.o中，只是记录了i符号会引用其他目标文件中数据区中的名为i的数据。

这样一来，在链接器（通常由编译器代为调用）将a.o和b.o链接成单个可执行文件（或者库文件）c的时候，c文件的数据区也只会有一个i的数据（供a.c和b.c的代码共享）。

而如果b.c中我们声明int i的时候不加上extern的话，那么i就会实实在在地既存在于a.o的数据区中，也存在于b.o的数据区中。

那么链接器在链接a.o和b.o的时候，就会报告错误，因为无法决定相同的符号是否需要合并。

而对于函数模板来说，现在我们遇到的几乎是一模一样的问题。

不同的是，发生问题的不是变量（数据），而是函数（代码）。这样的困境是由于模板的实例化带来的。

注意下文主要以函数模板为例，因为其只涉及代码，讲解起来比较直观。如果是类模板，则有可能涉及数据，不过其原理都是类似的。

比如，在一个test.h的文件中声明了如下一个函数模板：

// test.h
template <typename T> 
void fun(T) 
{ }

在第一个test1.cpp文件中，为了利用函数模板，定义了以下代码：

// test1.cpp
#include "test.h" 
void test1() 
{ 
    fun(1); 
}

而在另一个test2.cpp文件中，为了利用函数模板，定义了以下代码：

// test2.cpp
#include "test.h" 
void test2()
{
    fun(2);
}

由于两个源代码使用的函数模板的参数类型一致：

所以在编译test1.cpp的时候，编译器实例化出了函数fun<int>(int)，而当编译test2.cpp的时候，编译器又再一次实例化出了函数fun<int>(int)。

那么可以想象，在test1.o目标文件和test2.o目标文件中，会有两份一模一样的函数fun<int>(int)代码。代码重复和数据重复不同。

数据重复，编译器往往无法分辨是否是要共享的数据；而代码重复，为了节省空间，保留其中之一就可以了（只要代码完全相同）。

事实上，大部分链接器也是这样做的。在链接的时候，链接器通过一些编译器辅助的手段将重复的模板函数代码fun<int>(int)删除掉，只保留了单个副本。

这样一来，就解决了模板实例化时产生的代码冗余问题。可以看看下图中的模板函数的编译与链接的过程示意：

很明显，对于源代码中出现的每一处模板实例化，编译器都需要去做实例化的工作；而在链接时，链接器还需要移除重复的实例化代码。

很明显，这样的工作太过冗余，而在广泛使用模板的项目中，由于编译器会产生大量冗余代码，会极大地增加编译器的编译时间和链接时间。

解决这个问题的方法基本跟变量共享的思路是一样的，就是使用“外部的”模板。

【2】显式实例化与外部模板的声明

外部模板的使用实际依赖于C++98中一个已有的特性，即显式实例化（Explicit Instantiation）。

显式实例化的语法很简单，比如对于以下模板：

template <typename T>
void fun(T) {}

只需要声明：

template void fun<int>(int);

这就可以使编译器在本编译单元中实例化出一个fun<int>(int)版本的函数（这种做法也被称为强制实例化）。

而在C++11标准中，又加入了外部模板（Extern Template）的声明。

语法上，外部模板的声明跟显式的实例化差不多，只是多了一个关键字extern。对于上面的例子，可以通过：

extern template void fun<int>(int);

这样的语法完成一个外部模板的声明。那么回到一开始我们的例子，来修改一下我们的代码。

首先，在test1.cpp做显式地实例化：

// test1.cpp
#include "test.h"
template void fun<int>(int); // 显式地实例化 
void test1()
{ 
    fun(1);
}

接下来，在test2.cpp中做外部模板的声明：

// test2.cpp
#include "test.h"
extern template void fun<int>(int); // 外部模板的声明
void test2()
{
    fun(2);
}

这样一来，在test2.o中不会再生成fun<int>(int)的实例代码。整个模板的实例化流程如下图所示：

可以看到，由于test2.o不再包含fun<int>(int)的实例，因此链接器的工作很轻松，基本跟外部变量的做法是一样的，即只需要保证让test1.cpp和test2.cpp共享一份代码位置即可。

而同时，编译器也不用每次都产生一份fun<int>(int)的代码，所以可以减少编译时间。

这里也可以把外部模板声明放在头文件中，这样所有包含test.h的头文件就可以共享这个外部模板声明了。

这一点跟使用外部变量声明是完全一致的。

【3】外部模板的应用

应用外部模板注意问题：

（1）如果外部模板声明出现于某个编译单元中，那么与之对应的显示实例化必须出现于另一个编译单元中或者同一个编译单元的后续代码中。

（2）外部模板声明不能用于一个静态函数（即文件域函数），但可以用于类静态成员函数（显而易见，因为静态函数没有外部链接属性，不可能在本编译单元之外出现）。

应用示例：

[1] extern_template.h 外部模板头文件

// extern_template.h

__pragma(once)

#include <iostream>

// 模板

// 类
template <typename T>
class A {};

// 静态成员方法
template <typename T>
class B 
{
public:
    static void sm_f(T t)
    {
        std::cout << "B::sm_f :: " << t << std::endl;
    }
};

// 静态普通函数
template <typename T>
static void s_f(T t) 
{
    std::cout << "static s_f :: " << t << std::endl;
};

// 普通函数
template <typename T>
void func(T t)
{
    std::cout << "func :: " << t << std::endl;
};

 [2] extern_template.cpp 实例化

// extern_template.cpp

#include "extern_template.h"

// 实例化 

void test_f1()
{
    A<int> a;
    s_f(1);
    std::cout << "static general func" << std::endl;
}

void test_f2()
{
    func(1);
    std::cout << "general func" << std::endl;
}

void test_f3()
{
    B<int>::sm_f(1);
    std::cout << "static member func" << std::endl;
}

 [3] main.cpp 外部模板声明与应用

// main.cpp

#include <iostream>
#include "extern_template.h"

extern template class A<int>;            // 类
extern template void B<int>::sm_f(int);  // 静态成员函数

#if 0
extern template void s_f<int>(int);      // error C2129 静态函数“void s_f<int>(int)”已声明但未定义
#endif

extern template void func<int>(int);     // 普通函数

void test_f() 
{
    func(1);
    std::cout << "test_f" << std::endl;
}

int main()
{
    s_f(1);
    test_f();
    B<int>::sm_f(1);

    getchar();
    return 0;
}

/*
static s_f :: 1
func :: 1
test_f
B::sm_f t :: 1
*/

如上可见：静态函数没有外部链接属性，不可能在本编译单元之外出现。

good good study, day day up.

顺序 选择 循环 总结