【C++】模板（template）进阶

一、非类型模板参数

模板参数分为「类型形参」与「非类型形参」，注意：不管哪种模板参数，都可以给「缺省值」。

• 类型形参：出现在模板参数列表中，跟在 class 或者 typename 之后的参数类型名称。

  // T: 类型模板参数，它是一个类型
  template <class T> class A;
  

• 非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

  // T: 类型模板参数，它是一个类型
  // N: 非类型模板参数，它是一个常量
  template <class T, size_t N = 10> class A;
  

  比如：C++11 增加了一个容器 array，就是一个静态数组，通过非类型模板参数来控制数组的大小：

  template < class T, size_t N > class array; // 不推荐使用，容易导致栈溢出（栈是非常小的）
  

Example：只是举例子，不推荐这样写

现在实现了一个静态栈，可以存 10 个数据，实例化的每个对象都可以存 10 个数据，如果我想要第一个对象 st1 存 100 个数据，第二个对象存 200 个数据，这种结构就非常的不好。

#define N 10
template<class T> // 静态栈
class Stack {
private:
	T _a[N];
	size_t _top;
};

void test()
{
	Stack<int> st1; // 10
    Stack<int> st2; // 10
}

那该如何解决呢？-- 定义非类型模板参数(常量)：

template<class T, size_t N> // 静态栈
class Stack {
private:
	T _a[N];
	size_t _top;
};

void test()
{
	Stack<int, 100> st1; // 100
	Stack<int, 200> st2; // 200
    
	/* error! 必须要用常量
    int n;
    cin >> n;
    Stack st3;
	*/
}

注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的，一般都是用的 int 整型。
2. 非类型的模板参数必须在「编译期」就能确认结果。

拓展 & 思考：

1. C++ 缺点之一，后期如 C++11 等标准增加了不少鸡肋的语法，比如 array 和 forward_list，让语言变得很臃肿，学习成本增加。而一些刚需的东西，姗姗来迟，甚至还没来（比如官方的网络库）。
2. C++ 难点之一，C++ 的语法细节比较复杂。

---

二、模板特化

2.1 概念

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果。

比如：交换两个元素

template<class T>
void Swap(T& x, T& y)
{
	T tmp(x); x = y; y = tmp;
}

void test()
{
	int x = 1, y = 2;
	Swap(x, y);

	vector<int> v1 = { 1, 2, 3, 4 };
	vector<int> v2 = { 10, 20, 30, 40 };
	Swap(v1, v2); // 深拷贝式交换，代价太大，效率低
}

解决方案一：函数的匹配原则，写一个专门针对 vector 类型对象交换的函数：推荐这种

// 函数匹配原则，专门针对 vector 类型对象交换的函数 -- 推荐这种
void Swap(vector<int>& v1, vector<int>& v2)
{
	v1.swap(v2); // 只需要交换对象内部的几个指针即可
}

解决方案二：函数模板的特化，针对 vector 类型对象的交换进行特殊化处理：

// 函数模板的特化（针对某些具体类型进行特殊化处理） -- 最后还是要经过模板推演
template<>
void Swap<vector<int>>(vector<int>& v1, vector<int>& v2)
{
	v1.swap(v2);
}

此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。

模板特化分为：函数模板特化与类模板特化。

---

2.2 函数模板特化

函数模板的特化步骤：

1. 必须要先有一个基础的函数模板。
2. 关键字 template 后面接一对空的尖括号 <>
3. 函数名后跟一对尖括号 <>，尖括号中指定需要特化的类型。
4. 函数形参表：必须要和 <> 中指定的类型完全相同，如果不同，编译器可能会报一些奇怪的错误。

template<class T1, class T2>  // 基础函数模板
void add(T1& x, T2& y)
{
	cout << "void add(T1& x, T2& y)" << endl;
}

template<>
void add<int, char>(int& x, char& y)  // 函数模板的特化
{
	cout << "void add" << endl;
}

void test()
{
	int a = 1, b = 2;
	add(a, b);   // 走基础函数模板

	int c = 1;
	char d = 'a';
	add(c, d); // 走特化的void add版本
}

注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。

void add(int& x, char& y)
{
	cout << "void add(int& x, char& y)" << endl;
}

---

2.3 类模板特化

类模板的特化步骤：

1. 必须要先有一个基础的类模板。
2. 关键字 template 后面接一对空的尖括号 <>
3. 类名后跟一对尖括号 <>，尖括号中指定需要特化的类型。

类模板的特化分为：全特化 和 偏特化。

① 全特化

全特化：将模板参数列表中 所有的参数 都确定化。

template<class T1, class T2> // 基础类模板
class Data
{
public:
	Data() { cout << "Data" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

// 类模板的全特化 -- 最后还是要经过模板推演
// 将所有参数都确定化
template<>
class Data<double, double>
{
public:
	Data() { cout << "Data" << endl; }
private:
	double _d1;
	double _d2;
};

void test()
{
	Data<int, int> d1;       // 走基础类模板
	Data<double, double> d2; // 走特化的double版本
}

② 偏特化

偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。

比如对于以下类模板：

template<class T1, class T2> // 基础类模板
class Data
{
public:
	Data() { cout << "Data" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

偏特化有两种表现方式：

1. 部分特化：将模板参数类表中的一部分参数特化。

   // 类模板的偏特化
   // 将部分参数确定化
   template<class T1>
   class Data<T1, char>
   {
   public:
   	Data() { cout << "Data" << endl; }
   private:
   	T1 _d1;
   	char _d2;
   };
   
   void test()
   {
   	Data<int, int> d1;  // 走基础类模板
   	Data<int, char> d3; // 走特化版本
   }
   

2. 参数更进一步的限制：

   偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

   // 不一定式特化部分参数，而是对参数更进一步的限制
   // 两个参数偏特化为指针类型
   template<class T1, class T2>
   class Data<T1*, T2*>
   {
   public:
   	Data() { cout << "Data" << endl; }
   private:
   	T1* _d1;
   	T2* _d2;
   };
   
   // 两个参数偏特化为引用类型
   template<class T1, class T2>
   class Data<T1&, T2&>
   {
   public:
   	Data(const T1& d1, const T2& d2) 
   		:_d1(d1)
   		,_d2(d2)
   	{ 
   		cout << "Data" << endl; 
   	}
   private:
   	const T1& _d1;
   	const T2& _d2;
   };
   
   void test()
   {
   	Data<int, int> d1;         // 调用基础的类模板
       
       // 不管显示实例化什么类型的指针都可以
   	Data<int*, char*> d4;      // 调用特化的指针版本
   	Data<int*, int*> d5;       // 调用特化的指针版本
       
       // 不管显示实例化什么类型的引用都可以
       Data<int&, int&> d6(1, 2); // 调用特化的引用版本
   }
   

---

三、模板分离编译

3.1 概念

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

---

3.2 模板的分离编译

假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：

// func.h
template<class T>
T Add(const T& x, const T& y);
 
// func.cpp
#include"func.h"
template<class T>
T Add(const T& x, const T& y)
{
	return x + y;
}

// main.cpp
#include"func.h"
int main()
{
	Add(1, 2);
	Add(1.0, 2.0);
	return 0;
}

此段代码运行会报链接错误（链接错误一般是指在链接阶段找不到该函数的定义）：

无法解析的外部符号 "int __cdecl Add(int const &,int const &)" (??$Add@H@@YAHABH0@Z)，函数 _main 中引用了该符号

这是为什么呢？这就需要先了解下程序编译的过程了。

---

① 程序编译（⭐重要）

编译 (compilation, compile) ，编译程序就是把从源语言编写的 源程序 产生 目标程序 的过程。 把高级语言变成计算机可以识别的二进制语言（因为计算机只认识 1 和 0）

假设有如下代码：

// func.h
int Add(const int& x, int T& y); // 函数的声明
 
// func.cpp
#include"func.h"
int Add(const int& x, int T& y) // 函数的定义
{
	return x + y;
}

// main.cpp
#include"func.h"
int main()
{
	Add(1, 2);
	return 0;
}

C/C++程序要运行，一般要经历一下步骤：

预处理 --> 编译 --> 汇编 --> 链接

比如有 func.h、func.cpp、main.cpp 三个文件：

• 预处理：头文件展开、宏替换、条件编译、去掉注释等等。

  func.h、func.cpp、main.cpp -> func.i、main.i

• 编译：语法检查，函数实例化，生成汇编 .s 文件（注意：头文件不参与编译，编译器对工程中的多个源文件是分离开单独编译的）。

  func.i、main.i -> func.s、main.s

  汇编文件 .s 中存放的是汇编指令，在 main.s 文件中有一句调用函数的代码：

  00FD187C  call   @__CheckForDebuggerJustMyCode@4 (?)
  

  call 后面跟的这个 @__CheckForDebuggerJustMyCode@4 是编译器用函数名修饰规则修饰后的函数名，链接之前，括号中是没有地址的，因为 main.s 文件中只有函数的声明(头文件展开)，定义在 func.s 文件中，函数是声明与定义分离编译的，所以没有函数地址。

• 汇编：把汇编代码转成二进制机器码（CPU是不认识汇编代码的），生成 .o 目标文件

  func.s、main.s -> func.o、main.o

• 链接：将多个 .o 目标文件合并成一个可执行目标文件，并处理没有解决的地址问题（把 main.o 里面调用函数但没有函数地址的地方，拿函数名去其它目标文件 func.o 中找，找到以后填上，替换原来的*“虚假”*地址，再把目标文件合并到一起，生成可执行文件）

  注意：声明与定义分离编译的函数没有函数地址，声明和定义未分离编译的函数是有函数地址的

  func.o、main.o -> a.out

  此时你把 a.out 转成对应的汇编代码，那句调用函数的代码是这样的：

  00FD187C  call  @__CheckForDebuggerJustMyCode@4 (0FD1311h)
  

  括号中有函数地址，因为链接阶段，编译器通过函数名去函数定义的文件func.o中找到了函数的地址

---

② 问题分析

了解完程序编译的过程，模板的分离编译之所以会报链接错误，是因为在编译阶段生成汇编文件的过程（func.i -> func.s）就出现问题了。

函数模板的代码不能直接编译成二进制代码，需要有一个 “ 实例化 ” 的过程，而实例化要求编译器知道函数模板的定义。

再回到刚才的例子（将模板的声明和定义分离）：

// func.h
template<class T>
T Add(const T& x, const T& y); // 函数模板的声明
 
// func.cpp
#include"func.h"
template<class T>
T Add(const T& x, const T& y) // 函数模板的实现
{
	return x + y;
}
// func.cpp中没有调用Add函数的语句
// 所以Add和Add不会被实例化出来

// main.cpp
#include"func.h"
int main()
{
	Add(1, 2);     // call Add
	Add(1.0, 2.0); // call Add
	return 0;
}

分析：

在 main.cpp 中调用了 Add 和 Add 函数，但编译器并不知道函数模板的定义，因为它不在 func.h 里面，于是编译器只好寄希望于链接器，希望它能够在其它目标文件 func.o 中找到 Add 函数的实例（地址），然而，func. o 中并没有 Add 函数的二进制代码，因此链接时报错。

C++ 标准明确表示，当一个模板不被用到的时侯它就不该被实例化出来，在 func.cpp 中 没有调用过 Add 函数，所以在编译阶段 Add 函数模板 不会被实例化出来生成具体的代码，所以 func.i 编译汇编出来的 func.o 目标文件中没有关于 Add 函数的一行二进制代码，于是链接器只好给出一个链接错误。

但是，如果在 func.cpp 中写了一个函数，其中调用 Add 函数，或者显式指定实例化，则编译器会将其实例化出来，因为在 func.cpp 中，编译器知道模板的定义，所以能够实例化，于是，main.o 的符号导出表中也就有了 Add 函数的地址，链接器就能够完成任务，顺利生成可执行目标程序。

结论：

模板不支持分离编译

---

③ 解决方法

1. 不分离编译，将声明和定义放到一个文件 “xxx.h” 中，这样头文件展开后，main.cpp 中就有函数的定义，链接时就不需要去找函数的地址了，推荐使用这种。

2. 在模板定义的位置显式指定实例化。用一个类型就得显式实例化一个类型，很麻烦，不实用，不推荐使用。

   // func.h
   template<class T>
   T Add(const T& x, const T& y); // 函数模板的声明
    
   // func.cpp
   #include"func.h"
   template<class T>
   T Add(const T& x, const T& y) // 函数模板的实现
   {
   	return x + y;
   }
   template
   int Add(const int& x, const int& y); // 显示实例化函数模板
   template
   double Add(const double& x, const double& y); // 显示实例化函数模板
   
   // main.cpp
   #include"func.h"
   int main()
   {
   	Add(1, 2);     // call Add
   	Add(1.0, 2.0); // call Add
   	return 0;
   }
   

---

四、总结

优点：

1. 模板复用了代码，节省资源，可以更快的迭代开发，C++的标准模板库(STL)因此而产生。
2. 增强了代码的灵活性。

缺陷：

1. 模板会导致代码膨胀问题，也会导致编译时间变长。
2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误。

模板这个语法整体而言肯定是优点远大于缺点。

---