[C++知识库]C++ 函数模板 & 使用函数模板出现“无法解析的外部符号”的问题

一、C++ 函数模板

函数模板是通用的函数描述，它们使用泛型来定义函数，其中的泛型可用具体的类型替换。
通过将类型作为参数传递给模板，可使编译器生成该类型的函数。
由于模板允许以泛型（而不是具体类型）的方式编写程序，因此有时候也被称为通用编程。
在标准C++98添加关键字typename之前，C++使用关键字class来创建模板。
在C++11中，可以将class替换为typename。

template<class T>
void swap(T&a, T&b)
{
	T temp;
	temp = a;
	a = b;
	b = temp;
}

调用函数模板：

int a, b;
double c, d;
swap(a, b); //会生成void swap(int& a, int& b);
swap(c, d); //会生成void swap(double& a, double& b);

函数模板的重载

例如：

template <typename T>
void swap(T& a, T& b);

template <typename T>
void swap(T* a, T* b, int n);

int i = 10, j = 20;
swap(i, j);     // 调用第一个， int参数类型匹配

int d1[3] = {1, 2, 3};
int d2[3] = {4, 5, 6};
swap(d1, d2, 3);	// 调用第二个， T类型数组匹配 T*

模板函数的显示具体化

在编写C++程序时，很多情况下会同时使用函数模板和函数模板的显示具体化，假设有一个结构体，C++允许将一个结构体赋给另一个结构体，如果只想交换其中部分成员，则需要不同的代码。
可以提供一个具体化函数定义——显示具体化。当编译器找到与函数调用匹配的具体化时，将使用该定义，而不再寻找模板。

• 1.对于给定的函数名，可以有非模板函数，模板函数，和显示具体化函数以及它们的重载版本。
• 2.显示具体化的原型和定义应以template<>打头，并通过名称来指出类型。
• 3.具体化优先于常规模板，非模板函数优先于具体化和模板函数。

声明和定义

• 需要先声明函数模板，再声明函数模板的显示具体化，否则编译会报错，而函数模板和具体化的定义顺序则是无关紧要的
• 仅仅声明函数模板的具体化，而不声明函数模板，编译同样会报错
• 在先声明函数模板后，函数模板的显示具体化和显示实例化的顺序是无关紧要的

template <typename T>
void Swap(T &a, T &b);
 
template<> void Swap<job>(job &j1, job &j2);
 
template void Swap<int>(int &a, int &b);

void Swap(T &a, T &b)
{
	T temp;
	temp = a;
	a = b;
	b = temp;
}
 
template <> void Swap<job>(job &j1, job &j2)
{
	double t1;
	int t2;
	t1 = j1.salary;
	j1.salary = j2.salary;
	j2.salary = t1;
	t2 = j1.floor;
	j1.floor = j2.floor;
	j2.floor = t2;
}

模板函数的实例化

函数调用swap（i，j）导致编译器生成swap()的一个实例，该实例使用int类型。
模板并非函数定义，但使用int的模板实例就是函数定义，这种实例化方式被称为隐式实例化。
C++允许显示实例化，template void swap(int&, int & )

template <typename T>
void Swap(T &a, T &b);
template void Swap<int>(int &a, int &b);

or

template <typename T>
void Swap(T &a, T &b);
int a, b;
a = 6;
b = 8;
Swap<int>(a, b);

编译器选择使用哪个函数版本编译器选择使用哪个函数版本

对于函数重载，函数模板，函数模板重载，C++有定义一个良好的策略，来决定为函数调用使用哪一个函数定义，尤其是有多个参数时，这个过程称为重载解析。

• 1.完全匹配，但常规函数优先于模板。
• 2.提升转换（char 与short自动转换为int，float自动转换为double）。
• 3.标准转换（int转换为char，long转换为double）。
• 4.用户定义的转换，如类声明中定义的转换。

函数的变量类型与返回类型

函数有多个参数类型时

template <typename T1, typename T2>
void ft(T1 x, T2 y)
{
	decltype (x + y) xpt = x + y;
}

x + y 的类型无法预测出来，使用decltype关键字来猜测类型。

如果函数有返回值类型：无法预先知道x + y的类型，此时还未声明参数x 和 y，他们不在作用域内（编译器无法看到它们，无法使用它们）。必须在声明参数后使用decltype。

template <typename T1, typename T2>
auto ft(T1 x, T2 y)->decltype(x + y)
{
	decltype (x + y) xpt = x + y;
	return (x + y);
}

二、使用函数模板出现“无法解析的外部符号”的问题

使用函数模板的过程中，在类里面定义了一个函数模板，按照普通的类的定义方式，将声明放在了.h文件中，将函数体放在了.cpp文件中，即模板函数的声明和定义分开，编译的时候出现了“无法解析的外部符号”的问题 ----- C++编译器不支持模板的分离式编译。
当我们声明和定义一个模板的时候，必须要让声明和定义放在一个文件里，否则编译器会报错。

解决方法：

• 1.将类的声明和定义放在同一个.h文件中。
• 2.在类模板出现的cpp文件对应的.h文件中include .cpp文件。
• 3.在主函数所在的main.h中include .cpp文件。
• 4.模板函数实例化，模板函数实例化全局声明(dll文件也需要实例化全局声明)，如下：

template <typename T>
void Swap(T &a, T &b);
/*obj文件*/
template void Swap<int>(int &a, int &b);
/*dll文件*/
template __declspec(dllexport) void Swap<int>(int &a, int &b);

原理：

首先，一个编译单元（translation unit）是指一个.cpp文件以及它所#include的所有.h文件，.h文件里的代码将会被扩展到包含它的.cpp文件里，然后编译器编译该.cpp文件为一个.obj文件（假定我们的平台是win32），后者拥有PE（Portable Executable，即windows可执行文件）文件格式，并且本身包含的就已经是二进制码，但是不一定能够执行，因为并不保证其中一定有main函数。当编译器将一个工程里的所有.cpp文件以分离的方式编译完毕后，再由连接器(linker)进行连接成为一个.exe文件。

Example:

//---------------test.h-------------------//
void f();//这里声明一个函数f
 
//---------------test.cpp--------------//
#include”test.h”
void f()
{
 … //dosomething
} 
//这里实现出test.h中声明的f函数
 
//---------------main.cpp--------------//
#include”test.h”
int main()
{
 f(); //调用f，f具有外部连接类型
}
 
---------------------

在这个例子中，test. cpp和main.cpp各自被编译成不同的.obj文件（姑且命名为test.obj和main.obj），在main.cpp中，调用了f函数，然而当编译器编译main.cpp时，它所仅仅知道的只是main.cpp中所包含的test.h文件中的一个关于void f();的声明，所以，编译器将这里的f看作外部连接类型，即认为它的函数实现代码在另一个.obj文件中，本例也就是test.obj，也就是说，main.obj中实际没有关于f函数的哪怕一行二进制代码，而这些代码实际存在于test.cpp所编译成的test.obj中。在main.obj中对f的调用只会生成一行call指令，像这样：

call f [C++中这个名字当然是经过mangling[处理]过的]

在编译时，这个call指令显然是错误的，因为main.obj中并无一行f的实现代码。那怎么办呢？这就是连接器的任务，连接器负责在其它的.obj中（本例为test.obj）寻找f的实现代码，找到以后将call f这个指令的调用地址换成实际的f的函数进入点地址。需要注意的是：连接器实际上将工程里的.obj文件“连接”成了一个.exe文件，而它最关键的任务就是上面说的，寻找一个外部连接符号在另一个.obj中的地址，然后替换原来的“虚假”地址。

这个过程如果说的更深入就是：

call f这行指令其实并不是这样的，它实际上是所谓的stub，也就是一个jmp 0xABCDEF。这个地址可能是任意的，然而关键是这个地址上有一行指令来进行真正的call f动作。也就是说，这个.obj文件里面所有对f的调用都jmp向同一个地址，在后者那儿才真正”call”f。这样做的好处就是连接器修改地址时只要对后者的call XXX地址作改动就行了。但是，连接器是如何找到f的实际地址的呢（在本例中这处于test.obj中），因为.obj与.exe的格式是一样的，在这样的文件中有一个符号导入表和符号导出表（import table和export table）其中将所有符号和它们的地址关联起来。这样连接器只要在test.obj的符号导出表中寻找符号f（当然C++对f作了mangling）的地址就行了，然后作一些偏移量处理后（因为是将两个.obj文件合并，当然地址会有一定的偏移，这个连接器清楚）写入main.obj中的符号导入表中f所占有的那一项即可。

这就是大概的过程。其中关键就是：

编译main.cpp时，编译器不知道f的实现，所以当碰到对它的调用时只是给出一个指示，指示连接器应该为它寻找f的实现体。这也就是说main.obj中没有关于f的任何一行二进制代码。

编译test.cpp时，编译器找到了f的实现。于是乎f的实现（二进制代码）出现在test.obj里。

连接时，连接器在test.obj中找到f的实现代码（二进制）的地址（通过符号导出表）。然后将main.obj中悬而未决的call XXX地址改成f实际的地址。完成。

然而，对于模板，你知道，模板函数的代码其实并不能直接编译成二进制代码，其中要有一个“实例化”的过程。

Example：

//----------main.cpp------//
template<class T>
void f(T t)
{}
 
int main()
{
 …//do something
 f(10);  // call f<int> 编译器在这里决定给f一个f<int>的实例
 …//doother thing
}
---------------------

也就是说，如果你在main.cpp文件中没有调用过f，f 也就得不到实例化，从而main.obj中也就没有关于f 的任意一行二进制代码！如果你这样调用了：

f(10); // f<int>得以实例化出来
 
f(10.0); // f<double>得以实例化出来

这样main.obj中也就有了f，f两个函数的二进制代码段。以此类推。

然而实例化要求编译器知道模板的定义，不是吗？

看下面的例子（将模板的声明和实现分离）：

//-------------test.h----------------//
template<class T>
class A
{
 public:
 void f(); // 这里只是个声明
};
 
//---------------test.cpp-------------//
#include”test.h”
template<class T>
void A<T>::f()  // 模板的实现
{
 …//do something
}
 
//---------------main.cpp---------------//
#include”test.h”
int main()
{
 A<int> a; 
 a.f();	// #1
}
 
---------------------

编译器在#1处并不知道A::f的定义，因为它不在test.h里面，于是编译器只好寄希望于连接器，希望它能够在其他.obj里面找到A::f的实例，在本例中就是test.obj，然而，后者中真有A::f的二进制代码吗？
NO！！！因为C++标准明确表示，当一个模板不被用到的时侯它就不该被实例化出来，test.cpp中用到了A::f了吗？没有！！所以实际上test.cpp编译出来的test.obj文件中关于A::f一行二进制代码也没有，于是连接器就傻眼了，只好给出一个连接错误。但是，如果在test.cpp中写一个函数，其中调用A::f，则编译器会将其实例化出来，因为在这个点上（test.cpp中），编译器知道模板的定义，所以能够实例化，于是，test.obj的符号导出表中就有了A::f这个符号的地址，于是连接器就能够完成任务。

关键是：
在分离式编译的环境下，编译器编译某一个.cpp文件时并不知道另一个.cpp文件的存在，也不会去查找（当遇到未决符号时它会寄希望于连接器）。这种模式在没有模板的情况下运行良好，但遇到模板时就傻眼了，因为模板仅在需要的时候才会实例化出来，所以，当编译器只看到模板的声明时，它不能实例化该模板，只能创建一个具有外部连接的符号并期待连接器能够将符号的地址决议出来。然而当实现该模板的.cpp文件中没有用到模板的实例时，编译器懒得去实例化，所以，整个工程的.obj中就找不到一行模板实例的二进制代码，于是连接器也黔驴技穷了。

感谢：
https://blog.csdn.net/weixin_41681293/article/details/82254957
https://blog.csdn.net/qq_42128241/article/details/81632910
https://blog.csdn.net/Leo_csdn_/article/details/104880255