【C语言教程】将模板实现放入头文件原理详解

所需工具：

C++

聪明的大脑

勤劳的双手

 

注意：本站只提供教程，不提供任何成品+工具+软件链接，仅限用于学习和研究，禁止商业用途，未经允许禁止转载/分享等

 

教程如下

写在前面

本文通过实例分析与讲解，解释了为什么C++一般将模板实现放在头文件中。这主要与C/C++的编译机制以及C++模板的实现原理相关，详情见正文。同时，本文给出了不将模板实现放在头文件中的解决方案。

例子

现有如下3个文件：

 	// add.h
 	     template <typename T>
 	     T Add(const T & a, const T & b);
 	     // add.cpp
 	     #include "add.h"
 	     template <typename T>
 	     T Add(const T & a, const T & b)
 	     {
 	         return a + b;
 	     }
 	     // main.cpp
 	     #include "add.h"
 	     #include <iostream>
 	     int main()
 	     {
 	         int res = Add<int>(1, 2);
 	         std::cout << res << "\n";
 	         return 0;
 	     }

现象

使用 g++ -c add.cpp 编译生成 add.o ，使用 g++ -c main.cpp 编译生成 main.o ，这两步都没有问题。

使用 g++ -o main.exe main.o add.o 生成 main.exe 时，报错 undefined reference to ‘int Add(int const& , int const& )’ 。

当然，直接 g++ add.cpp main.cpp -o main.exe 肯定也会报错，这里把编译和链接分开是为了更好地展示与分析问题。

原因

出现上述问题的原因是：

（1）C/C++源文件是按编译单元（translation unit）分开、独立编译的。所谓translation unit，其实就是输入给编译器的source code，只不过该source code是经过预处理（pre-processed ，包括去掉注释、宏替换、头文件展开）的。在本例中，即便你使用 g++ add.cpp main.cpp -o main.exe ，编译器也是分别编译 add.cpp 和 main.cpp （注意是预处理后的）的。在编译 add.cpp 时，编译器根本感知不到 main.cpp 的存在，反之同理。

（2） C++模板是通过实例化(instantiation)来实现多态(polymorphism)的。以函数模板为例，首先需要区分“函数模板”和“模板函数”。本例中，上面代码的第8~12行是函数模板，顾名思义，它就是一个模子，不是具体的函数，是不能运行的；当用具体的类型，如 int ，实例化模板参数 T 后，会生成函数模板的一个具体实例，称为模板函数，这是真正可以运行的函数。“函数模板”和“模板函数”的关系，可以类比“类”和“对象”的关系。以 int 为例，生成的实例/模板函数大概长这样（细节上肯定和编译器的实际实现有出入，但核心意思不会变）。

 	     int Add_int_int(const int & a, const int & b)
 	     {
 	         return a + b;
 	     }

对于每一个用到的具体类型，编译器都会生成对应版本的实例，当函数调用时，会调用到该实例。如用到了 Add<int> ，就会生成 Add_int_int ，用到了 Add<double> ，就会生成 Add_double_double ，等等。本例中，当编译器编译到第20行，即 int res = Add<int>(1,2); 一句时，编译器就会试图生成 int 版本的模板实例（即模板函数）。

（3）编译器为模板生成实例的必要条件是：1. 知道模板的具体定义/实现；2. 知道模板参数对应的实际类型。

分析

下面把上面两节内容结合起来分析。

（1）当编译 add.cpp 时，相当于编译

 	     template <typename T>
 	     T Add(const T & a, const T & b);
 	     template <typename T>
 	     T Add(const T & a, const T & b)
 	     {
 	         return a + b;
 	     }

此时编译器虽然知道模板的具体定义，却不知道模板参数 T 的具体类型，因此不会生成任何的实例化代码。

（2）当编译 main.cpp 时，相当于编译

 	     #include <iostream>
 	     template <typename T>
 	     T Add(const T & a, const T & b);
 	     int main()
 	     {
 	         int res = Add<int>(1, 2);
 	         std::cout << res << "\n";
 	         return 0;
 	     }

当编译到 int res = Add<int>(1, 2); 时，编译器想要生成 int 版本的函数实例，但它找不到函数模板的具体定义（即 Add 的“函数体”），只好作罢。好在编译器看到了函数模板的声明，于是通过了编译，将寻找 int 版本函数实例的任务留给了链接器。

至此，编译 add.cpp 时，只知模板定义，不知模板类型参数，无法生成具体的函数定义；编译 main.cpp 时，只知模板类型参数，不知模板定义，同样无法生成具体的函数定义。

（3）没什么好说的，链接器在 add.o 和 main.o 中都没找到 int 版本的 Add 定义，直接报错。

解决方案

方案一

传统方法：把模板实现也放在头文件中。

 	// add.h
 	     template <typename T>
 	     T Add(const T & a, const T & b)
 	     {
 	         return a + b;
 	     }
 	     // main.cpp
 	     #include "add.h"
 	     #include <iostream>
 	     int main()
 	     {
 	         int res = Add<int>(1, 2);
 	         std::cout << res << "\n";
 	         return 0;
 	     }

当编译 main.cpp 时，相当于编译

 	     #include <iostream>
 	     template <typename T>
 	     T Add(const T & a, const T & b)
 	     {
 	         return a + b;
 	     }
 	     int main()
 	     {
 	         int res = Add<int>(1, 2);
 	         std::cout << res << "\n";
 	         return 0;
 	     }

此时编译器既知道函数模板的定义，又知道具体的模板类型参数 int ，因此可以生成 int 版本的函数实例，不会出错。

这种方式的优缺点如下：

优点：可以按需生成。假如我们在 main.cpp 中调用了 Add<double>(1.0, 2.0); ，编译器就会为我们生成 double 版本的函数实例。
缺点：不得不把实现细节暴露给用户。

方案二

模板声明和定义分离的方案。

 	     // add.h
 	     template <typename T>
 	     T Add(const T & a, const T & b);
 	     // add.cpp
 	     #include "add.h"
 	     template <typename T>
 	     T Add(const T & a, const T & b)
 	     {
 	         return a + b;
 	     }
 	     template int Add(const int & a, const int & b);
 	     // main.cpp
 	     #include "add.h"
 	     #include <iostream>
 	     int main()
 	     {
 	         int res = Add<int>(1, 2);
 	         std::cout << res << "\n";
 	         return 0;
 	     }

注意， template int Add(const int & a, const int & b); 是函数模板实例化（function template instantiation）[1]， template 关键字不能省略，否则， int Add(const int & a, const int& b); 会被编译器当做普通函数的声明，从而在链接时又会报 undefined reference to ‘int Add(int const& , int const& )’ 错误。

对于这种写法，编译器在编译 add.cpp 时，既能看到函数模板的定义，又能看到具体的模板类型参数 int ,于是生成了 int 版本的函数实例，整个程序可以正常编译运行。

很显然，这种情况下编译器只生成了 int 版本的函数实例，所以，在 main.cpp 中使用 Add<double>(1.0, 2.0); 这样的代码肯定是不可以的。这种情况的优缺点可以辩证看待：

优点：

1. 可以隐藏实现细节（我们可以把 add.cpp 做成.lib或.dll）；
2. 也可以限制只实例化特定的版本。

缺点：就是只能使用特定的几个版本，不能像方案一那样在编译 main.cpp 时根据具体的调用情况按需生成。

从这里也可以看出，模板实现不一定非得放在头文件中。

参考

[1] Function template – cppreference.com

[2] c++ – Why can templates only be implemented in the header file – Stack Overflow