C++要笑着学：非类型模板参数 | 模板的特化

   C++ 表情包趣味教程 👉 《C++要笑着学》

💭 写在前面

我们之前讲过C++的模板，考虑到当时还没有将 STL，所以并没有一次性讲完，我们把剩余的部分放到了讲完部分 STL 容器的后面去讲，这样比较方去讲解。比如我们本章我们会通过 STL 的 array 去讲解非类型模板参数。本章还会重点讲解模板的特化，最后简单的探讨一下C++引入模板的优缺点。

 本篇博客全站热榜排名：未上榜

---

Ⅰ. 非类型模板参数（Nontype Template Parameters）

0x00 引入：什么是非类型模板参数？

" 对于函数模板和类模板，模板参数并不局限于类型，普通值也可以作为模板参数 "

  STL 的 array 就有一个非类型模板参数。

注意看，我们普通定义的 T 是类型，而 N 这里并不是类型，而是一个常量！

类型模板参数定义的是虚拟类型，注重的是你要传什么，而 非类型模板参数定义的是常量。

               "非类型模板参数"
                     👇
template<class T, size_t N> class array;
             👆    
        "类型模板参数"

0x01 非类型模板参数的使用场景

💭 举例：假设我们要定义一个静态栈： 

#define N 100
 
template<class T> 
class Stack {
    private:
        int _arr[N];
        int _top;
};

❓ 思考：我现在想定义两个容量不一样的栈，一个容量是100 另一个是 500，能做到吗？

这就像 typedef 做不到一个存 int 一个存 double，而使用模板可以做到 st1 存 int，st2 存 double。

这里你的 #define 无论是改 100 还是改 500 都没办法解决这里的问题，

对应的，这里使用非类型模板参数就可以做到 s1 存 100，s2 存 500。

💡 解决方案：定义一个常量 N

// #define N 100
 
template<class T, size_t N>
class Stack {
    private:
        int _arr[N];
        int _top;
};
 
int main(void) 
{
    Stack<int, 100> st1;     // 我期望它的大小是100
    Stack<double, 500> st2;  // 我期望它的大小是500
 
    return 0;
}

这里我们在模板这定义一个常量 N，派遣它去做数组的大小。

于是我们就可以在实例化 Stack 的时候指定其实例化对象的大小了，分别传 100 和 500。

 这比宏更爽！它能传一个常量过去，定义不同的对象可以传不同的常量过去。

0x02 一些值得注意的点

📌 注意事项 ①：非类型模板参数是是常量，是不能修改的。

template<class T, size_t N> 
class Stack {
    public:
        void f() {    // 修改常量试试看
            N = 10; 
        }
    private:
        int _arr[N];
        int _top;
};
 
int main(void) 
{
    Stack<int, 100> st1;
    st1.f();
 
    return 0;
}

🚩 运行结果：（报错）

test1711.cpp:10:15: error: lvalue required as left operand of assignment
             N = 10;
             ~~^~~~

📌 注意事项②：有些类型是不能作为非类型模板参数的，比如浮点数、类对象以及字符串。

非类型模板参数基本上都是整型，实际上也只有整型是有意义和价值的（可以这么理解）。

（char 也算整型，只不过是一个字节的整型，你不能因为它一个字节就歧视它）

📌 注意事项③：非类型的模板参数必须在编译期就能确认结果。

0x03 顺便介绍一下 STL 的 array

 " 我们对 STL 的 array 安排的场次如此潦草，在这里穿插下随便讲讲好啦 "

🔍 官方文档：array - C++ Reference

现在学了非类型模板参数了，我们现在再来回头看 array：

array 是 C++11 新增的，它有什么独特的地方吗？

 很可惜，基本没有，并且 vector 可以完全碾压 array……

而且就算说它有，那也不是优势反而是劣势，这就是为什么我们没有这么积极的讲解 array。

#include 
#include 
#include 
using namespace std;
 
int main(void)
{
    vector<int> v1(100, 0);
    array<int, 100> a1;
    
    cout << "size of v1: " << sizeof(v1) << endl;
    cout << "size of a1: " << sizeof(a1) << endl;
 
    return 0;
}

🚩 运行结果：

vector 是开在空间大的堆上的而 array 是开在寸土寸金的栈上的，堆可比栈的空间大太多太多了。

最尴尬的是 array 能做的操作几乎 vector 都能做，因为 vector 的存在 array 显得有些一无是处。

 所以我们拿 array 去对标 vector 是不对的，拿去和原生数组比还是可以对比的。

但是 array 也只是封装过的原生数组罢了，是真的菜：

array<int, 100> a1;  // 封装过的原生数组
int a2[100];         // 原生数组

比起原生数组，array 的最大优势也只是有一个越界的检查，读和写都可以检查到是否越界。

要对比的话也只能欺负一下原生数组，然而面对强大的 vector，array 完全没有招架之力。

如何评价 array？在 C++11 增加完 array 后备受吐槽，从简化的角度来说完全可以不增加 array。

 我的评价是 —— 

" 十年磨一剑，但磨的是十年前的技术 "

🔺 总结：array 相较于原生数组，有越界检查之优势，实际中建议直接用 vector。

Ⅱ. 模板的特化（Template Specialization）

0x01 引入：给特殊类型准备特殊模板

 通常情况下，使用模板可以实现一些与类型无关的代码

但是，对于一些特殊类型，可能我们就要对其进行一些 "特殊的处理" 。

💭 举例：如果不对特殊类型进行特殊处理就可能会出现一些问题，比如：

#include 
#include "Date.h"    /* 引入自己实现的日期类 */
using namespace std;
 
/* 判断左数是否比小于右数 */
template<class T>
bool Less(T left, T right) {
    return left < right;
}
 
int main(void)
{
    cout << Less(1, 2) << endl;        // 可以比较，结果正确
 
    Date d1(2022, 7, 7);
    Date d2(2022, 7, 8);
    cout << Less(d1, d2) << endl;      // 可以比较，结果正确
 
    Date* p1 = new Date(2022, 7, 16);
    Date* p2 = new Date(2022, 7, 15);
    cout << Less(p1, p2) << endl;      // 可以比较，结果正确
 
    return 0;
}

❓ 运行结果：（我们运行几次发现，其结果不稳定，对于 Date* 一会是真一会是假）

问题出在没传指针，传的是 p1 和 p2，这里传 *p1 和 *p2 就能解决。但是……

 这时候冲出个土匪拿炸弹强迫你：不让你传星号，就必须传 p1 和 p2，怎么办？

不慌，我们还可以用一种特殊的方式 —— 模板的特化，针对某些类型要进行特殊化处理。

0x01 模板特化的步骤

 首先，必须要先有一个基础的函数模板。

 其次，关键字 template 后面接上一对空的 <> 尖括号。

 然后，函数名后跟一对尖括号，尖括号中指定需要特化的内容。

 最后，函数形参表必须要和模板函数的基础参数类型完全相同，不同编译器会恶心人。

💬 代码演示：模板的特化

#include 
#include "Date.h"
using namespace std;
 
// 必不可少的原本
template<class T>
bool Less(T left, T right) {
    return left < right;
}
 
// 针对某些类型要特殊化处理 ———— 使用模板的特化解决
template<>
bool Less(Date* left, Date* right) {
    return *left < *right;
}
 
int main(void)
{
    cout << Less(1, 2) << endl;       // 可以比较，结果正确
 
    Date d1(2022, 7, 7);
    Date d2(2022, 7, 8);
    cout << Less(d1, d2) << endl;     // 可以比较，结果正确
 
    Date* p1 = new Date(2022, 7, 16);
    Date* p2 = new Date(2022, 7, 15);
    cout << Less(p1, p2) << endl;     // 可以比较，结果正确  
 
    return 0;
}

🚩 运行结果：（运行多次后发现结果正常，每次都一致）

💡 解读：对于普通类型，它还是会调正常的模板。对于 Date* 编译器就会发现这里有个专门为 Date* 而准备的特化版本，编译器会优先选择该特化版本。这，就是模板的特化。

 当然了，函数内你可以自己设计如何去处理你想要处理的特殊情况，这都是你说的算：

template<>
bool Less(Date* left, Date* right) {
    // 这里面你可以做各种处理
}

❓ 思考：现在我们加一个普通函数，Date* 会走哪个版本？

// 原模板
template<class T>
bool Less(T left, T right) {
    return left < right;
}
 
// 对模板特化的
template<>
bool Less(Date* left, Date* right) {
    return *left < *right;
}
 
// 直接匹配的普通函数
bool Less(Date* left, Date* right) {
    return *left < *right;
}

🔑 答案：函数重载，会走直接匹配的普通函数版本，因为是现成的，不用实例化。你可以这么理解：原模板是生肉，模板特化是半生不熟的肉，直接匹配的普通函数是熟肉。

🔺 结论：函数模板不一定非要特化，因为在参数里面就可以处理，写一个匹配参数的普通函数也更容易理解。

0x02 类模板的特化

 刚才函数模板不一定非要特化，因为可以写一个具体实现的函数。

但是类模板我们没法实现一个具体的实际类型，就必须要特化了。

💭 比如这里 d2 需要接收一个 int 和 一个 double 的值：

#include 
#include "Date.h"
using namespace std;
 
template<class T1, class T2>
class Data {
public:
	Data() {
		cout << "Data" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};
 
int main(void)
{
	Data<int, int> d1;
	Data<int, double> d2;   // 需要特化解决
 
	return 0;
}

💬 代码演示：类模板的特化

template<class T1, class T2>
class Data {
public:
	Data() {
		cout << "Data" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};
 
// 类模板的特化
template<>
class Data<int, double> {
public:
	Data() {
		cout << "Data" << endl;
	}
};
 
int main(void)
{
	Data<int, int> d1;
	Data<int, double> d2;
 
	return 0;
}

🚩 运行结果：

0x03 全特化和半特化

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

（我们刚才写的就是全特化）

...
// 全特化
template<>
class Data<int, double> {
public:
	Data() {
		cout << "Data" << endl;
	}
};

 半特化（又称偏特化）：将部分参数类表中的一部分参数特化。

（半特化并不是特化一半，就像半缺省并不是缺省一半一样）

...
// 半特化（偏特化）
template<class T1>
class Datachar> {
public:
	Data() {
		cout << "Data" << endl;
	}
};
 
int main(void)
{
	// 只要第二个值是 char 都会匹配到半特化
	Data<int, char> d3;
	Data<char, char> d4;
 
	return 0;
}

 半特化还有一种表现方式，半特化可以用来对参数进行更进一步的限制。

💬 代码演示：限制两个参数都是指针

...
// 半特化还可以对参数进行进一步限制
template<class T1, class T2>
class Data {
public:
	Data() {
		cout << "Data" << endl;
	}
};
 
int main(void)
{
	// 只要你两个参数都是指针，就匹配
	Data<int*, char*> d5;
	Data<char*, string*> d6;
	Data<char**, void*> d7;
 
	return 0;
}

🚩 运行结果：

💬 代码演示：限制两个参数都是引用

template<class T1, class T2>
class Data {
public:
	Data() {
		cout << "Data" << endl;
	}
};
 
int main(void)
{
	// 只要你两个参数都是引用，就匹配
	Data<int&, int&> d8;
	Data<char&, string&> d9;
 
	return 0;
}

🚩 运行结果：

Ⅲ. 模板的优缺点

0x00 优点

① 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库（STL）因此而产生。

② 增强了代码的灵活性。

0x01 缺点

① 模板会导致代码膨胀问题，也会导致编译时间变长。

② 出现模板编译错误时，错误信息非常凌乱，不易定位错误。

---

📌 [ 笔者 ]   王亦优
📃 [ 更新 ]   2022.8.1
❌ [ 勘误 ]   /* 暂无 */
📜 [ 声明 ]   由于作者水平有限，本文有错误和不准确之处在所难免，
              本人也很想知道这些错误，恳望读者批评指正！