原文出处：彻底征服C++模板

前言

模板是C++体系中非常重要的一环，由其衍生的模板编程体系也算得上是C++特色，但也因为它学习门槛较高，语法很奇怪、反直觉让人望而却步。

笔者也经常碰到有人问我类似于「C++不写模板难道就不行吗？」「我们团队直接禁止写模板，我也没觉得对我的开发有什么影响啊。」「你这些特性我不用模板也能实现啊。」之类的问题。笔者仍然持有「困难的东西我们应当攻克下，再去客观评判其合理性。而不是为自己的逃避找开脱的理由」的态度，与此同时，笔者还认为「“能做”并不代表“适合”」，工具是用来帮助我们提升效率的，只有当我们充分了解了，才能判断何为「适用的场景」，从而真正让工具为我们的工作提供服务。因此感觉非常有必要出一篇完整且详细讲解C++模板编程的教程，来打通你的任督二脉。

本系列文章将会介绍如下的内容：

1. C++模板的基础知识，包括基础的语法和用法
2. C++模板的进阶知识，包括模板编译方式、特化和SFINAE法则
3. 模板元编程，这里会讲解其的思路和体系结构，并用一个手撸variant的项目作为终极实例
4. 「模板范式」的概念和其设计理念
5. 一些读者关心的问题的解答以及笔者的心得体会

一些说明：

• 本文编写时C++20标准已经发行了一段时间了，但在业界还并不成熟，编译器对C++20标准的支持参差不齐，并且C++20标准的权威文档、示例等也比较匮乏，目前很少有团队在生产环境推行C++20标准的。因此出于这样大环境的考虑，本文主要以C++17为默认的标准，重点介绍的也是C++17标准下的各种情况，对于C++17、C++14、C++11和C++98则不会做特别的标注和区分。而对于C++20上会有比较重大变化，或是其他涉及C++20标准的点时会特别标注出来。
• 「使用了模板」跟「模板元编程」是两回事，模板元编程是一套理论体系，模板仅仅是C++的一种语法类型。本文会先介绍模板的用法，然后也会介绍模板元编程。
• 本文不是C++语言的入门教程，也不适合从来没有见过C++模板的读者，作为C++进阶性的用法，模板可以认为比基础C++语言更高一个层次，需要读者至少有C++语言的基础。本文更适合有稍微「涉猎」过C++模板编程，对它虽有些许支离破碎的理解和感悟，但希望建立一个完整、宏观的视角的读者，那么本篇文章会帮助你把这些碎片全部穿起来，建立一个完整的世界观，让你对C++模板的认识更上一层楼。
• 本文在创作时原本的标题是《C++模板元编程详细教程》，但是后来发现其内容并不局限于模板元编程，而是帮助读者由浅入深从模板的基础概念开始建立，并把模板元编程仅作为了其中一个子单元存在，更加注重「穿线」和「引导」，因此将其更名。
• 如果读者有任何问题，欢迎在评论区指正。笔者在后续发现文章问题的时候也会持续更正。

C++模板的基础用法

模板的概念

「模(mú)板」原本是工程上的概念，我们用「浇注」这个工序更好理解。首先你得有个模具，里面是空心的，空心的形状正好是最终工件的形状。然后我们把铁水浇注进去，等冷却后，打开模具，取出里面的工件。

从上面的例子我们可以总结出这么两个要点：

模具本身不是工件，得用模具来生成工件

最终的工件材料取决于浇注进去的材料（比如说浇注铁水出铁件，浇注铝水就出铝件），模具只决定工件的形状

类比到C++的模板也是一样的：

模板本身不是实际代码，得用模板来生成代码（这个过程叫「实例化」）

用模板实例化的代码取决于模板参数，模板本身只是一个「实例化的方式」（这一点能够解释很多时候为什么模板本身没有报错，但是实例化后报错了。）

那么这里我们能够看到模板拥有2个要点：「参数（类比工件材料）」和「实例化方式（类比工件形状）」

写一个hello world级别的模板

有了上一节的2个要点，我们自然而然就可以引出模板的基本语法，下面展示一个最简单的模板：

template <typename T>
void show(T t) {
  std::cout << t << std::endl;
}

template是模板关键字，表示后面即将定义一个模板。后面尖括号中的就是「模板参数」，这就是模板的第1个要点。之后的所有内容叫做「模板实现」，对应模板的第2个要点。

详细一点来解释就是，上面定义了一个「定义函数的方法」，参数中的T就是「材料」。把「材料」浇注到「模具」中就可以形成工件，也就是说，指定了「参数」的「模板函数」就可以形成「函数」。

那么使用模板的方法，就是给模板传递参数，使其实例化成为一个可实际调用的代码。以上面的例子来讲就是：

void Demo() {
  show<int>(5); // 首先实例化show<int>函数，然后再调用show<int>函数
}

这里请读者一定一定要建立一个概念，模板本身并不是可使用的代码，必须实例化以后才是。也就是说，这里的show并不是函数，而是「模板函数」。「模板函数」经过实例化后才能成为「函数」，而函数才能直接调用。

那么上面使用模板就分了2个步骤。首先，给模板函数show指定参数，将其实例化成show<int>，成为一个函数。那么，这个show<int>函数怎么定义呢？那就要看模板是怎么实现的了（这就是前一节说的，模板其实规定了实例化的方式）。因此，我们这里得到的函数是：

void show<int>(int t) {
  std::cout << t << std::endl;
}

第二步才是调用这个函数，所以这里尖括号中的int是模板参数，而小括号中的5则是函数实参。

请读者先熟悉并接受上面的理念，更加详细和深入的内容会在后面章节逐渐展开。

模板的分类

要问C++模板有哪些分类，倒不如问「哪些语法可以用模板生成」。按照这个维度，我们可以将模板分为：

- 模板类
- 模板函数
- 模板全局常量
- 模板类型重命名

接下来会简单展示一下各种类型的语法和大致用法。注意：下面很多例程可能都不是非常准确，这里是为了方便读者理解才写的一个简化版本，不能够直接投入使用。

模板类

顾名思义，模板类就是用于生成「类」的模板。不过这里的「类」并不是单指class，我们知道在C++中，class和struct的区别仅仅在默认权限上，因此几乎都可以互相代替，不过这仅仅实在「语法」上。在实际使用中，我们更在意它直观表达的「语义」，因此对于纯数据类型的组合，一般更习惯用struct，而对于带有操作的自定义类型（或者理解为OOP中的「抽象」），一般更习惯用class。比如我们可以写一个模板struct：

template <typename T1, typename T2>
struct Test {
  T1 t1;
  T2 t2;
};

只不过照着这种习惯来讲，「纯数据类型组合」似乎并没有太多写成模板的价值，所以对于模板类来说，class和struct的使用习惯还有那么一点不同。在模板类中，如果是用于「生成对象」的模板类，我们更习惯用class，而对于「模板元编程」的静态语言描述中，我们更习惯用struct。由于我们还没有详细介绍什么是「模板元编程」，因此读者暂且不必过多纠结，只需要知道struct关键字的模板也属于模板类就可以了。

下面例程就是一个简单的模板类和实例化调用的例子：

template <typename T, size_t size>
class Array {
 public:
  Array();
  T &at();
  size_t size() const;
 private:
  T data_[size];
};

void Demo() {
  Array<int, 5> arr; // 实例化，并创建对象
  arr.at(1) = 6;
}

关于实例化的步骤，读者可以参考「写一个hello world级别的模板」章节中的描述。

刚才我们说，class和struct都可以模板化，成为模板类。那union呢？其实union跟struct是基本类似的，唯一的区别在于成员共享首地址。因此从语法上来说，同样是支持union模板的:

template <typename T1, typename T2>
union Test {
  T1 m1_;
  T2 m2_;
};

只不过这种用法就跟「纯数据类型组合」的struct写成模板后类似，虽然语法上可行，但实际使用场景真的寥寥无几就是了（当然，一些炫技的骚操作除外，后面章节会详述）。

模板函数

模板函数就是用模板生成一个函数，主体是一个函数。当然，普通函数、成员函数、包括lambda表达式都是可以写成模板的。下面就一口气给出这几个语法的例程：

// 普通模板函数
template <typename T>
void show(const T &item) {
  std::cout << item << std::endl;
}

class Test {
 public:
  // 模板成员函数
  template <typename T>
  void mem_func(const T &item) {}
};

// 模板lambda表达式（只能是全局变量承载）
template <typename T>
auto f = [](const T &item) {}

实例化和使用的方式大致如下：

void Demo() {
  show<int>(5);
  Test t;
  t.mem_func<double>(5.1);
  f<char>('A');
}

模板全局常量

模板的全局常量一般是由一个模板类来做「引导」的，而且由于模板必须在编译期实例化，因此模板全局常量一定也会在编译期有一个确定的值，必须由constexpr修饰，而不可以是「变量」（不加constexpr的模板全局变量虽然语法允许，但并不完全符合模板定义的初衷，它更像是「生成不同类型的全局变量的一种语法糖」，远不及模板全局常量的意义大，所以暂时请读者建立「模板全局变量必须是常量表达式」的印象）。

下面给出一个例程：

// 用于引导模板全局常量的模板类(用于判断一个类型的长度是否大于指针)
template <typename T>
struct IsMoreThanPtr {
  static bool value = sizeof(T) > sizeof(void *);
};

// 全局模板常量
template <typename T>
constexpr inline bool IsMoreThanPtr_v = IsMoreThanPtr<T>::value;

这样的用法在后面章节所要介绍的「模板元编程」中非常重要的作用，后续会详细介绍。

模板类型重命名

C++中的类型重命名主要有两种语法，一种是typedef，另一种是using，它们都支持模板生成，效果是相同的。

模板类型重命名可以直接借用一个模板类来做「偏特化」，或者也可以像模板全局常量一样由一个模板类来引导，请看下面例程：

// 普通的模板类
template <typename T, size_t size>
class Array {};

// 偏特化作用的模板类型重命名
template <typename T>
using DefaultArray = Array<T, 16>;

// 也可以作用给typedef语法
template <typename T>
typedef DefaultArray<T *> DefaultPtrArray;

void Demo() {
  DefaultArray<int> arr1; // 相当于Array<int, 16> arr1;
  DefaultPtrArray<char> arr2; // 相当于Array<char *, 16> arr2;
}

再展示一个由模板类做引导的例子：

// 用于引导的模板类
template <typename T>
struct GetPtr {
  using type = T *;
};

// 用模板类引导的模板类型重命名
template <typename T>
using GetPtr_t = typename GetPtr<T>::type;
void Demo() {
  GetPtr_t<int> p; // 相当于typename GetPtr<int>::type p; 也相当于int *p;
}

上面这种写法同样在模板元编程中非常重要，后续章节会详细讲解。

模板参数

在上一章节中，我们展示了几种基本的模板语法，相信读者也注意到了在例程中展示的一些模板参数。那么这一节笔者将详细介绍模板参数。

C++的模板参数主要分为三种：

1. 类型
2. 整数（或整数的衍生类型）
3. 模板

类型好理解，就是这个参数要求传入某种「数据类型」。整数也好理解，就是字面意思。但这个「整数的衍生类型」还有「模板参数模板」就比较有趣且复杂了，下面我们来逐一攻克。

类型模板参数

模板参数中最常用的就是这里的类型了，用于传递一个类型来实例化模板。关键字是typename。先看一个简单的例子：

template <typename T>
void show(T t) {
  std::cout << t << std::endl;
}

show是一个模板函数，接受1个参数T，并且它是一个类型参数。实例化的时候，就需要在T的位置传入一个类型标识符（例如int、void*或者std::string）。

void Demo() {
  show<int>(5);
  show<void *>(nullptr);
  show<std::string>("abc");
}

这里值得一提的是，在早些版本的C++中，用于表示类型参数的关键字是class，但是这个关键字可能会产生歧义，让人觉得这里必须要传一个「类」类型。但其实并不是这样的，基本类型也是OK的。所以后续又支持了typename关键字来表示类型参数，更加贴近语义一些。不过class也保留下来了，现在用来表示「模板的类型参数」这里，两个关键字是相同的，没有区别。所以上面的例程也可以写作：

template <class T>
void show(const T &t) {
  std::cout << t << std::endl;
}

正如上面例程展示的这样，类型模板参数除了直接使用以外，还可以和其他符号（比如*、&、&&、const等）进行组合。

整数

我们在前面的章节也展示过整数作为模板参数的情况，当时的例子是：

template <typename T, size_t size>
class Array {
  // ...
 private:
  T data[size];
};

那么这里的size就是整数，当然不止size_t类型，一切整型都是支持的，比如说int、short、char，甚至bool都是可以。

但这里需要再次强调一点，我们多次强调的一个问题，模板是编译期语法，因此，这里的整型数据也必须是编译期能确定的，比如说常数、常量表达式等，而不可以是动态的数据。请看下面例程：

// 整数参数的模板
template <int N>
struct Test {};

void Demo() {
  Test<5> t1; // 常数OK
  constexpr int a = 5;
  Test<a> t2; // 常量表达式OK

  const int b = 6;
  Test<b> t3; // ERR，b是只读变量，不是常量
  Test<a * 3> t4; // 常数运算OK

  std::vector<int> ve {1, 2, 3};
  Test<ve.size()> t5; // ERR，size是运行时数据
  Test<ve[1]> t6; // ERR，ve的成员是运行时数据

  int arr1[] {1, 2, 3};
  Test<arr1[0]> t6; // ERR，arr1的成员是运行时数据
  constexpr int arr2[] {2, 4, 6};
  Test<arr2[1]> t7; // 常量表达式修饰的普通数组成员OK
}

所以请读者把握一个原则，就是只有编译期能够确定的量，才能用来实例化模板。

在C++20以前，只允许整数参数，但从C++20起，可以支持浮点数做参数，同样，只要是编译期能确定的量就OK：

// C++20标准：
template <double C>
struct Test {};

整数的衍生类型

说到整数的衍生类型，也就是说「可以用整数表示」，或者说「本质上是整数」的类型。

指针类型

这里面最经典的就是指针，请看下面例程：

template <int *p>
void f(int data;) {
  *p = data;
}

不过这里实例化时能够支持的数据就很有说头了。既然我们说指针是整数的衍生类型（指针本质就是地址，地址就是个整数），那么规则自然也是跟整数的规则是一样的，要「编译期能够确认的值」。

只不过，对于指针来说，「编译期能够确认的值」就应该指的是「编译期能够确定的地址」。但这显然是个伪命题，因为编译期根本不存在地址的概念，程序在只有在进程预加载的时候才会确定所有变量的地址。所以这个问题需要我们换一个角度来看。如果说某一个变量，它的地址在程序运行期间能够一直不发生改变，或者说它不会中途被释放的话，我们就认为这个变量的地址是「确定的」。或者说，这个地址一旦确定要给这个变量来使用，那么它就一直都会给它使用，而不会中途变成交给其他变量。

沿着这个思路，只要是「程序运行中确定的」地址，就可以用来实例化模板。下面给出一些实例：

int a = 1; // 全局变量

class Test {
 public:
  int m1; // 成员变量
  static int m2; // 静态成员变量
};

int Test::m2 = 4;

void Demo() {
  int b = 2; // 局部变量
  static int c = 3; // 静态局部变量
  f<&a>(0); // OK，a是全局变量，程序运行期间不会被释放
  f<&b>(0); // ERR，b是局部变量，在局部代码块运行完毕后会被释放，所以说b的地址也有可能不仅仅表示b，回收后可能会表示其他数据，所以不可以
  f<&c>(0); // OK，c是静态局部变量，不会随着代码块的结束而释放
  f<&Test::m1>(0); // ERR，Test::m1其实并不是变量，要指定了对象才能确定，因此是非确定值，所以不可以
  f<&Test::m2>(0); // OK，Test::m1本质就是一个全局变量，在程序运行期间不会被释放，所以OK
}

希望读者能够通过上面的例子来理解什么是「不变的地址」，其实并不说是说地址不可变，因为地址本身就是不可变的。这里说的是，这个地址一直只表示确定的数据，而不会改变（不会被释放后重新分配给其他数据）。

函数类型

既然讲到指针类型，那我们也逃不开一类特殊的指针——函数指针。函数指针其实本质上也是地址，所以同样属于整数的衍生类型。而分配给函数（指令段）的地址在程序执行过程中就是不会变的，但如果用的是变量的值那么同样会因为动态数据问题而报错。

文字解释不直观，我们还是来看例程：

// 函数指针类型模板参数
template <void (*func)()>
void f() {
  func();
}

// 普通函数
void f1() {}
class Test {
 public:
  void f2() {} // 成员函数
  static void f3() {} // 静态成员函数
};

void Demo() {
  void (*pf1)() = &f1; // 局部变量
  constexpr void (*pf2)() = &f1; // 常量表达式
  f<&f1>(); // OK，函数本身就是地址不可变的
  f<&Test::f2>(); // ERR，虽然成员函数也是地址不可变的，但&Test::f2的类型是void (Test::*)()，类型不匹配所以报错
  f<&Test::f3>(); // OK，静态成员函数是地址不可变的，类型也匹配
  f<pf1>(); // ERR，pf1是静态数据，编译期值不确定，所以不可以
  f<pf2>(); // OK，用常量表达式修饰的在编译期可以确定，所以可以
}

在C语言中，直接使用函数名其实就会转义为函数指针类型。但C++引入了「函数类型」的概念，它在很多时候也是可以转换为函数指针类型的。那么在模板参数中，同样也支 持了「函数类型」，用法跟上述函数指针类型完全相同，并且还可以跟函数指针类型互用：

// 函数类型模板参数
template <void func()>
void f() {
  func();
}

// 普通函数
void f1() {}
class Test {
 public:
  void f2() {} // 成员函数
  static void f3() {} // 静态成员函数
};

void Demo() {
  void (*pf1)() = &f1; // 局部变量
  constexpr void (*pf2)() = &f1; // 常量表达式
  f<f1>(); // OK
  f<&f1>(); // OK
  f<Test::f3>(); // OK
  f<&Test::f3>(); // OK
  f<pf2>(); // OK
  // 与前一例程相同，不再赘述
}

同样地，「函数类型」本身就可以隐式转换为「函数指针类型」，因此使用上都是互通的，就不再赘述了。不过这里提前剧透一下，虽然在大多数情况下函数类型和函数指针类型都可以互转，没有明显区别，但在一种特殊场景下二者会有着天壤之别，详情会在后续介绍到模板偏特化的章节中提到。

模板类型

这个类型非常容易让人晕菜，所谓「模板类型的模板参数」，其实就是嵌套模板的意思，把「某一种类型的模板」作为一个参数传给另一个模板。请看示例：

// 模板类型的模板参数
template <template <typename, typename> typename Tem>
void f() {
  Tem<int, std::string> te;
  te.show();
}

// 符合条件的模板类
template <typename T1, typename T2>
struct Test1 {
  void show() {std::cout << 1 << std::endl;}
};

template <typename T1, typename T2>
struct Test2 {
  void show() {std::cout << 2 << std::endl;}
};

// 不符合条件的模板类
template <int N>
struct Test3 {
  void show() {std::cout << 3 << std::endl;}
};

void Demo() {
  f<Test1>(); // 注意这里，要传模板，而不是实例化后的模板
  f<Test<int, int>>(); // ERR，模板参数类型不匹配
  f<Test2>(); // OK
  f<Test3>(); // ERR，类型不匹配
}

上述例子中，模板函数f接受一个参数，这个参数需要是一个模板类型，并且是一个「含有2个类型参数的模板」类型。

在实例化的示例中，Test1和Test2都是template <typename, typename>类型，所以可以用来实例化f。

而实例化后的Test<int, int>已经是一个普通类型了，也就是说它是一个typename类型，而不是template <typename, typename>类型，所以不匹配。同理，Test3是template <int>类型，也不是template <typename, typename>类型，所以不匹配。

变参模板

所谓的「变参」指的是「参数数量可以是任意的」，变参模板并不是独立的一种类型参数，我们可以认为它是「一组参数」，可以是一组类型参数，也可以是一组非类型参数。

先举一个例子来直观感受一下变参模板，我们写一个支持任意个数的参数相加的函数：

template <typename... Args>
auto sum(Args... args) {
  return (... + args);
}

// 以下是测试Demo
void Demo() {
  auto a = sum(1, 2, 3, 4); // 10
  auto b = sum(1.5, 2, 3l); // 6.5
  auto c = sum(std::string("abc"), "def", "111"); // std::string("abcdef111")
  auto d = sum(2); // 2
}

相信读者不难看得出，这三个点就表示变参，不过三个点书写的位置是有讲究的，不同的位置表示的含义也略有不同。在上面的例子中，模板参数含有一个typename... Args，其中的三个点顿在了typename后面，表示这是一组类型参数，可以叫它「包（pack）」，而后面的Args就是这个「包」的名字。那么我们就知道，Args代表的并不是一个单一类型，而是一组类型参数组成的包。注意，模板的变参结构跟其他变参结构类似，都是只能出现一次，并且必须在列表最后，否则会造成解析的歧义。同时，变参结构在实际传递时，参数可以为空。

在函数参数中，可以看到有个Args...，由于Args本身是个包，那么给包后面加三个点表示「解包（Unpack）」，或者叫「展开（Unfold）」。所以参数中的解包，我们可以解读为，把Args中的每一个类型，平铺开，每一个类型都要对应一个函数的入参。而后面的args代表的就是这一组参数，它同样是一个「包」，但它则是由形参（本质就是局部变量）组成的包。

函数体中，可以看到出现了(... + args)的表达式，大家应该能猜到，这也是一种「解包」的语法，但这属于「按符号解包」的方式，与之对应的还有一种「直接解包」的方式，下面来分别讲解。

变参的直接展开

所谓「直接展开」，其实指的是按「逗号」展开，逗号不仅仅指逗号运算，任何以逗号为分割符的地方都支持变参的展开。比如说，给一片自定义的内存资源池适配一个创建对象的方法，就可以这样来写（简化一下，先不考虑左右值传递的问题）：

std::byte memory[16384]; // 这是一片内存资源池
void *head = memory; // 可用空间的头指针

// 在内存资源池上创建对象的函数
template <typename T, typename... Args>
T &Create(Args... args) {
  auto &obj = *new(head) T(args...);
  head += sizeof(T);
  return obj;
}

这里就是一个非常典型的直接展开的例子，展开后的参数会用逗号隔开。比如说我们这样调用：

struct Test {
  Test(int, double) {}
};

void Demo() {
  auto test = Create<Test, int, double>(1, 2.5); // 会通过Test(int, double)构造函数构造
}

上面实例化的Create<Test, int, double>类型，首先模板参数在展开的时候，Args中含有两个类型，分别是int, double，这里就是用逗号展开的。后面的args中也是含有两个变量，同样是按照逗号隔开，所以其实实例化后的函数是这样的：

Test &Create(int arg1, double arg2) {
  auto &obj = *new(head) Test(arg1, arg2);
  head += sizeof(Test);
  return obj;
}

变参的嵌套展开

刚才我们介绍的是直接展开，但有时可能我们要在变参的基础上嵌套一个什么结构，然后再展开的，比如说：

// 把数组中的某些角标元素取出来，组成新数组
template <typename T, int... N>
std::vector<T> GetSubVector(const std::vector<T> &src) {
  return std::vector<T> {src.at(N)...};
}

// 示例Demo
void Demo() {
  std::vector<int> ve {0, 11, 22, 33, 4};
  auto ve2 = GetSubVector<int, 1, 4, 1, 3, 0>(ve);
  // 执行后ve2会变成{11, 4, 11, 33, 0}
}

上面这个例子中，N是一个包，并且是整数包，对它展开的时候就没有用N...这样直接展开，而是加了一层结构，按照src.at(N)...的方式展开。这样展开后，每一个参数都会嵌套相同的结构，并且它们之间也是用逗号隔开的。所以GetSubVector<int, 1, 4, 1, 3, 0>其实会实例化成：

std::vector<int> GetSubVector(const std::vector<int> &src) {
  return std::vector<int> {src.at(1), src.at(4), src.at(1), src.at(3), src.at(0)}; // N的嵌套方式展开
}

按照符号展开

在C++17以前，变参只可以用逗号展开。回到一开始的例子，我们来实现任意个数的数相加，如果只能逗号展开，那么我们只能把它展开成函数参数，进行递归传递：

// 递归终止条件（只有1个参数的情况）
template <typename T>
auto sum(T arg) {
  return arg;
}

// 2个以及以上的情况要进行递归
template <typename Head, typename... Args>
auto sum(Head head, Args... args) {
  return head + sum<Args...>(args...);
}

为了递归，我们就需要强行把第一个参数分离出来，并且还要写一个只有一个参数的特殊情况。下面来看一下调用的示例：

void Demo() {
  auto a = sum<double, int, int, double>(1.5, 2, 2, 1.6);
}

首先，sum<double, int, int, double>不符合只有1个参数的条件，所以会命中下面的模板，实例化后的样子是：

auto sum(double head, int arg0, int arg1, double arg2) {
  return head + sum<int, int, double>(arg0, arg1, arg2);
}

它会要求调用一个sum<int, int, double>函数，所以会继续实例化：

auto sum(int head, int arg0, double arg1) {
  return head + sum<int, double>(arg0, arg1);
}

又会要求调用一个sum<int, double>，继续实例化：

auto sum(int head, double arg0) {
  return head + sum<double>(arg0);
}

又会要求调用一个sum<double>，但是此时，命中了上面的模板定义，所以会按照上面的方式来实例化，变成：

auto sum(double arg) {
  return arg;
}

到此截止，实现了一串数相加。这里提到的递归是模板实例化层面的递归，也就是递归生成模板实例化，而不是传统意义上的函数递归调用，这部分的详情在后面的章节还会有更加深入的介绍，当前只希望读者知道，在C++17以前，实现这种若干数相加的模板其实是不太容易的，需要借助这种模板递归。

但是在C++17提供了另一种变参展开方式，就是按照一个特定的符号展开（而不是逗号），可以极大程度上简化问题，增加代码可读性。这种按照符号展开的语法又被称为「折叠表达式」。我们再来看看一开始那个例子：

template <typename... Args>
auto sum(Args... args) {
  return (... + args);
}

这里的(... + args)就是折叠表达式，表示按照加号展开。我们知道，运算符是有优先级和合并顺序的，因此要按符号展开，就必须指定这种展开顺序，换句话说，((a ⊕ b) ⊕ c)和(a ⊕ (b ⊕ c))到底选哪一种的问题（这里的「 ⊕ 」代指任意二元运算符）。

对于这个问题，C++的解决方案是通过变参包名和三个点的位置来示意（注意，这里就是一种强行的规定，没什么道理可言），三个点在左的，表示从左到右合并；三个点在右边的，表示从又到左合并。也就是：

(... + args)

会展开为

((((arg0 + arg1) + arg2) + ...) + argn)

而反过来的：

(args + ...)

则会展开为

(arg0 + (arg1 + (... + (argn_1 + argn))))

注意，折叠表达式两端必须有括号！。

我们刚才提到，折叠表达式只支持二元运算符，既然是二元运算符，如果遇到只有一个参数的时候怎么办呢？这时这个符号会被忽略，直接返回原值，所以sum<int>就会实例化为：

auto sum(int arg) {
  return arg;
}

这就是我们使用折叠表达式不需要单独定义递归截止条件的原因。

说到二元运算符，就不得不聊到另一个问题，假如说我并不是希望仅仅包内的内容自行结合，而是要结合一个额外的内容呢？举例来说：

// 实现一个输出打印任意参数的功能
template <typename... Args>
void Show(Args... args) {
  std::cout << (... << args); // 想想，如果这样写是对的吗？
}

上例中，并不是希望把所有参数自行通过左移运算得出后的结果去输出的，而是要「把第一个参数先跟cout结合，第二个参数应当跟前面的运算结果（同样还是cout）再集合，之后都是依次跟前面的结合」。所以这个需求下，cout就成了一个要参与表达式展开的一个内容了，所以C++提供了这种情况下的解决方法，就是把这个额外的操作数也写进折叠表达式：

template <typename... Args>
void Show(Args... args) {
  (std::cout << ... << args); // 注意括号还是不能丢
}

那么上面的表达式展开后就变成了：

((((std::cout << arg0) << arg1) << ...) << argn)

这样就强行让cout也参与了表达式的展开。我们知道cout其实是std::ostream的一个实例，其左移运算对应的函数原型是：

class ostream {
 public:
  template <typename T>
  std::ostream &operator <<(T &&);
};

也就是说，cout和任何一个数据发生运算后，仍然会返回cout本身，所以按照上面的方式展开后，的确可以让cout依次和所有的变参相结合，达成我们「逐一输出」的目的。

我们把这种有额外内容参与的展开方式称为「二元展开」，相对的，前面那种方式就叫「一元展开」。注意，这里的「一元」「二元」并不表示运算符，因为不管是一元展开还是二元展开，都只能用二元运算符展开。这里的几元表示的是参与展开的成员有几个，如果只有一个包，自己内部展开的，就叫「一元展开」；而这种除了一个包，还需要一个额外内容参与展开的，就叫「二元展开」了。

同理，二元展开也有向右展开的版本：

(args ⊕ ... ⊕ obj)

这种的就会从右开始结合。所以大家一定要注意，二元展开中，那个额外的内容，一定要写在三个点的同一侧（毕竟三个点的方向表示展开的方向），否则无意义。例如下面的折叠表达式中，有两个就是无意义的：

(a + ... + args); // 二元展开，从左侧开始，先与a结合
(args ^ ... ^ a); // 二元展开，从右侧开始，先与a结合
(a - args - ...); // ERROR！语法错误
(... & args & a); // ERROR！语法错误
a - (args - ...); // 一元展开，展开后再与外面的内容进行运算
(... & args) & a; // 一元展开，展开后再与外面的内容进行运算

变参展开在后续内容中非常常见，也是极其重要的内容，请读者一定要理解其用法。

C++模板进阶知识

模板参数自动推导

前面的篇幅我们讲解了C++模板的基本用法，并且强调了模板并非直接可用的代码，需要经历「实例化」，而实例化的过程其实就是指定参数的过程。

但如果模板只能通过显式指定参数来进行实例化的话，那C++模板的「威力」也就止步于此了，进而也就不会出现复杂的模板元编程体系这样的东西。所以C++模板还有一个非常重要的特性，就是模板参数的自动推导。

模板参数的自动推导主要分为3种：

1. 根据函数参数自动推导（模板函数）
2. 根据构造参数自动推导（模板类）
3. 自定义构造推导（模板类）

需要强调的一点是，自动推导只能推导类型参数，而整数和整数派生参数是没法推导的，只能靠显式传入。

下面就来逐一介绍。

根据函数参数自动推导

本条针对的是模板函数。再次强调，模板参数和函数参数是不同的东西，用于实例化模板的参数是模板参数，用于调用函数的参数是函数参数。直观上来说，尖括号里的是模板参数，圆括号里的是函数参数。

我们先来看一个例子：

template <typename T>
void show(T t) {
  std::cout << t << std::endl;
}

void Demo() {
  int a = 5;
  show(a); // [1]
  show(5); // [2]
}

在上述例程中，show是一个模板函数，在下面两处标记的位置我们是直接调用show的，而没有指定模板参数，那么这时，就会触发模板参数的自动推导。

先来看一下[1]位置的调用，由于我们传入了参数a，编译器就会根据a的类型来推导模板参数T。在模板函数show的声明处，参数列表是(Tt)，所以T会根据a的类型来推导。那么问题来了，这里到底会推导出int还是int &还是const int还是const int&？

答案也很简单，模板参数的自动推导是完全按照auto的推导原则进行的。

也就是说，这里相当于auto t = a;，会推导出int，因此T会推导出int。

同理，针对于[2]位置的调用，我们传入的是一个常量5，照理说int、const int、const int &、int &&、const int &&都可以匹配，但根据auto的推导原则，仅仅保留「最简类型」，所以仍然会推导出int。

那么[1]和[2]的位置其实相当于：

show<int>(a); // [1]
show<int>(5); // [2]

再次强调，推导的原则与auto相同。那么同样地，也就支持和*、&、&&、const的组合，下面给出几个实例：

template <typename T>
void f1(T &t) {}

template <typename T>
void f2(const T &t) {}

template <typename T>
void f3(T *p) {}

void Demo() {
  f1(5); // 会报错，因为会推导出f1<int>，从而t的类型是int &，不能绑定常量
  int a = 1;
  f1(a); // f1<int>，t的类型是int &
  f2(a); // f2<int>，t的类型是const int &
  f3(a); // 会报错，因为会推导出f3<int>，此时t的类型是int *，int不能隐式转换为int *
  f3(&a); // f3<int>， t的类型是int *
}

这里需要注意的是，T是按照auto法则来推导的，但由于我们加上了修饰符，所以实际的函数参数t的类型是会带上这种描述符的，详情可以看上面例程的注释。

既然模板参数类型推导是按照auto法则，那就不得不提到一个特殊的推导，它就是auto &&。我们知道auto &&会根据绑定对象的左右性来推导出左值引用或是右值引用，同理对于用&&修饰的参数，在自动推导时也会拥有这样的特性。

换句话说，T &&也可以绑定可变值，此时会推导出左值引用。请看下面例程：

template <typename T>
void f4(T &&t) {}

void Demo() {
  int a = 5;
  const int b = 10;
  f4(1); // f4<int>，t的类型是int &&
  f4(a); // f4<int &>，t的类型是int &
  f4(b); // f4<const int &>，t的类型是const int &
  f4(std::move(a)); // f4<int>，t的类型是int &&
}

因此，这里总结出2条规律：

1. 当T &&匹配到可变值（也就是C++11里定义的「左值」）的时候，T会推导出左值引用，再根据引用折叠原则，最终实例化为左值引用
2. 当T &&匹配到不可变值（也就是C++11里定义的「右值」）的时候，T会推导出基本类型，最终实例化为右值引用

对于auto &&来说，我们只关心最终推导出的类型，并不会关心auto本身到底代表了什么。但对于模板的类型推导则不同，我们既要关心「模板参数推导出了什么类型」，又要关心「模板实例化后的函数参数是什么类型」。换做上面的例子来说就是，我们既要关系T推导出了什么，又要关心当T确定以后，t会变成什么类型。

那么按照上面的规律总结可以知道，即便我们传入的本身是一个右值引用（比如上面的std::move(a)），T依然会推导为int而并不是int &&。只不过实例化后的函数参数t的类型会变成int &&。

我相信有的读者在这里一定会产生疑问，既然「T推导出int」跟「T推导出int &&」的结果都是「t的类型是int &&」，那何必还要在此纠结呢？照目前的情况来说f4<int>和f4<int &&>可能确实看不出太大区别，但它会影响到模板的特化。如果我们定义了该种类型的特化，则会出现完全不同的行为。有关模板特化的内容将在后续章节详细讲解，请读者在此时记住，利用函数参数自动推导出的模板参数永远不会推导出右值引用，只可能推导出左值引用或者基本类型，这一点对于后续模板元编程是一个很重要的基础概念。

除了与引用、指针等组合外，还可以跟其他模板进行嵌套组合，编译器同样可以推导出正确的类型，请看例程：

template <typename T>
struct Test {};

template <typename T>
void f(const Test<T> &t) {}

void Demo() {
  Test<int> t1;
  Test<char> t2;
  f(t1); // 推导出f<int>，t的类型是const Test<int> &
  f(t2); // 推导出f<char>，t的类型是const Test<char> &
}

这种技巧非常适用于各种模板库（比如说STL），例如我们希望把一个vector的内容连续地放入一个buffer中，就可以这样来写：

#include <vector>
#include <cstdlib>
#include <cstddef>

template <typename T>
void CopyVec2Buf(const std::vector<T> &ve, void *buf, size_t buf_size) {
  if (buf_size < ve.size() * sizeof(T)) {
    return;
  }
  std::memcpy(buf, ve.data(), ve.size() * sizeof(T));
}

void Demo() {
  std::vector<int> ve{1, 2, 3, 4};
  std::byte buf[64];
  // 把ve的内容连续地复制到buf中
  CopyVec2Buf(ve, buf, 64); // 这里会推导出CopyVec2Buf<int>
}

模板函数之间还会存在重载问题，并且可能会引发二义性冲突，这部分内容将在后续章节详细介绍。

根据构造参数自动推导

模板函数可以通过函数参数来自动推导，那么模板类呢？当然就是通过构造参数来推导了。

先来看一个简单的例子：

template <typename T1, typename T2>
class Pair {
 public:
  Pair(const T1 &t1, const T2 &t2);
  void show() const;
 private:
  T1 t1_;
  T2 t2_;
};

template <typename T1, typename T2>
Pair<T1, T2>::Pair(const T1 &t1, const T2 &t2) : t1_(t1), t2_(t2) {}

template <typename T1, typename T2>
void Pair<T1, T2>::show() const {
  std::cout << "(" << t1_ << ", " << t2_ << ")" << std::endl;
}

void Demo() {
  Pair pair1{'a', 3.5}; // Pair<char, double>
  pair1.show();
  int a = 5;
  std::string str = "abc";
  Pair pair2{a, str}; // Pair<int, std::string>
  pair2.show();
}

上面的例子很好理解，就不过多赘述。但C++总是一种很「缺德」的语言，有的时候它的行为就是跟我们的直觉是相差甚远的，比如说：

template <typename T>
struct Test {
  Test(const T &t) {}
};

void Demo() {
  Test t{"abc"}; // 推导出Test<char[4]>类型
}

是不是很无厘头？这里传入的字面量"abc"，所以符合我们直觉的应当是，字符串字面量会处理为一个全局区的数据，然后在局部用其地址代替，那么这里应当是Test<const char *>才对，但结果并不是我们想的这样的。

究其原因，我们还是要对C++的语法定义进行一些深入的研究。对于字符串字面量来说，编译器会把它识别为一个全局的字符数组，对于代码中出现的相同字符串字面量，都会用同一个全局字符数组来代替。举例来说：

void Demo() {
  auto s1 = "abc";
  const char *s2 = "abc";
  std::string s3 = "abc";
}

当编译期发现有一个字符串字面量"abc"的时候，就会把它提取成一个全局的字符数组。所以上面的例子等价于：

const char g_str1[] {'a', 'b', 'c'};
void Demo() {
  auto s1 = g_str1; // auto推导出const char *类型
  const char *s2 = g_str1; // 数组类型隐式转换为首元素的指针类型
  std::string s3{g_str1}; // 调用了string(const char *)构造函数
}

而当字符串字面量直接初始化字符数组的时候，并不会生成全局的字符数组，而是直接成为了初始化字符数组的语法糖：

char str[] = "abc";
// 等价于
char str[] {'a', 'b', 'c', 0}; // 此时不会有g_str1之类的全局数组出现

因此，很多人印象中，「字符串字面量就是const char *类型」这个观念，其实是有一点点小问题的。因为它会被编译期理解为数组，而「数组」除了包含了首地址，还包含了长度的概念。只不过在大多数情况下，数组会“退化”成指针类型罢了。为了验证这个说法，我们做一个非常简单的小实验就好了：

#include <iostream>

int main() {
  std::cout << sizeof("1234") << std::endl; // 5
  std::cout << sizeof(const char *) << std::endl; // 8
  return 0;
}

通过静态sizeof运算就可以验证上面的说法，因此"1234"其实是const char [5]类型，而不是const char *。

所以回到一开始的例子，用一个字符串字面量去实例化模板类的时候，编译器会识别为数组语法，因此把T推导为char[4]类型，而构造参数t就成为了const char (&)[4]类型，这是一个数组的引用类型。

template <typename T>
struct Test {
  Test(const T &t) {}
};

void Demo() {
  Test t{"abc"}; // 推导出Test<char[4]>类型
}

但假如我们的模板类里有一些成员操作的话，就会导致这里报错，比如说:

template <typename T>
struct Test {
  Test(const T &t): mem_(t) {}
  T mem_;
};

void Demo() {
  Test t{"abc"}; // 报错
}

实例化时会报错，原因就在于，构造函数中我们用t去初始化mem_，而此时mem_是char [4]类型，t是const char(&)[4]类型（本质上就是char [4]类型的常引用），两个数组类型是不能直接复制的，所以会报错。

但如果这时，我们显式实例化的话：

template <typename T>
struct Test {
  Test(const T &t): mem_(t) {}
  T mem_;
};

void Demo() {
  Test<const char *> t{"abc"}; // OK
}

由于Test被强制实例化为Test<const char *>，那么此时t的类型就变成了const char* const类型，然后再接收字符串字面量的时候，数组类型会转化为数组首元素指针类型，也就是const char [4]转化为了const char*。而此时的mem_是const char *类型，自然就可以进行初始化的操作了（两个指针当然可以直接赋值）。

那这种情况要怎么办呢？我们能不能想办法让它不出现这种数组类型的实例化呢？答案是肯定的，那就要用到「模板参数类型推导指南」了，详见下节「自定义构造推导」。

自定义构造推导

为了「促使」模板类能够按照我们希望的方式来进行类型推导并实例化，当我们发现自动的类型推导不满足需求的时候，就可以考虑添加一种自定义的构造推导，这个语法称之为「推导指南(Deduction Guide)」。

当定义了推导指南后，编译期会优先根据推导指南来进行实例化，如果没有合适的推导指南，才会根据构造函数参数来进行实例化。我们用推导指南来解决上一节实例化字符数组的问题：

template <typename T>
struct Test {
  Test(const T &t): mem_(t) {}
  T mem_;
};

// Deduction Guide
template <typename T>
Test(T)->Test<T>;

void Demo() {
  Test t{"abc"}; // Test<const char *>
}

具体解释一下推导指南的语法，就是说对于类型Test，当构造参数是T的时候，我们要实例化为Test<T>。

相信有的读者看到这里会想，这不是废话嘛……本来不也是按这种方式推导的呀？但其实并不是！因为推导指南会按照函数调用法则来识别，也就是说，这里的Test(T)应当看做一个函数，当我们把const char [4]类型的参数传进函数参数的时候，就会转换为const char*。所以拥有了推导指南后，T会识别为const char *，再根据指南，实例化的结果就是Test<const char *>了。

当然了，遇到一些特殊需求（比如说你希望它推出对应的指针类型）也是可以方便地用推导指南来实现的：

template <typename T>
struct Test {};

template <typename T>
Test(T)->Test<T *>;

void Demo() {
  int a = 0;
  Test t{a}; // Test<int *>
}

甚至可以做一些更定制化的组合，比如说：

template <typename T>
struct Test {
  Test(T t) {}
};

template <typename T>
Test(T)->Test<T>;

// 如果传2个参数，按第二个走
template <typename T1, typename T2>
Test(T1, T2)->Test<T2>;

void Demo() {
  int a = 0;
  double b = 2.5;
  Test t1{a}; // Test<int>
  Test t2{a, b}; // Test<double>，注意此时调用的是Test<double>::Test(int, double)构造函数，又因为这个构造函数不存在所以会报错，可以通过偏特化解决
}

所以推导指南的用法远不止展示的这么简单，大家可以根据需要来发挥，另外它在后面重点介绍的模板元编程中也起了相当大的作用，希望读者可以理解渗透，打好基础。

模板特化

有了前面的基础，相信大家对模板编程已经有一点初步的感觉了。趁热打铁，这一章我们主要来介绍一下模板特化。

首先来看一下下面的例子：

template <typename T>
void add(T &t1, const T &t2) {
  t1 += t2;
}

上面是一个简单的模板函数，用于把第二个参数的值加到第一个参数中去。这个模板函数对于基本数据类型的实例化都是没什么问题的，但是如果是字符串的话，那将会有问题：

void Demo() {
  int a = 1, b = 3;
  add(a, b); // add<int>，调用符合预期
  char c1[16] = "abc";
  char c2[] = "123";
  add(c1, c2); // add<char *>， 调用不符合预期
}

这里的问题就在于，对于字符串类型（这里指原始C字符串，而不是std::string）来说，「相加」并不是简单的+=，因为字符串主要是用字符指针来承载的，指针相加是不合预期的。我们希望的是字符串拼接。

因此，我们希望，单独针对于char *的实例化能够拥有不同的行为，而不遵从「通用模板」中的定义。这种语法支持就叫做「特化」，或「特例」。可以理解为，针对于模板参数是某种特殊情况下进行的特殊实现。

因此，我们在通用模板的定义基础上，再针对char *类型定义一个特化：

#include <cstring>
template <typename T>
void add(T &t1, const T &t2) {
  t1 += t2;
}

template <> // 模板特化也要用模板前缀，但由于已经特化了，所以参数为空
void add<char *>(char *&t1, char *const &t2) { // 特化要指定模板参数，模板体中也要使用具体的类型
  std::strcat(t1, t2);
}

void Demo() {
  int a = 1, b = 3;
  add(a, b); // add<int>是通过通用模板生成的，因此本质是a += b，符合预期
  char c1[16] = "abc";
  char c2[] = "123";
  add(c1, c2); // add<char *>有定义特化，所以直接调用特化函数，因此本质是strcat(c1, c2)，符合预期
}

上例简单展示了一下模板特化目标解决的问题，和其基本的语法。但其实模板特化远不止如此，它有着巨大的潜力。

模板的特化分两种情况，一种是全特化（有的地方也叫特例），一种是偏特化（有的地方也叫部分特化）。全特化相对简单一些，笔者会先来介绍。而偏特化会伴随SFINAE理论，它将会成为模板元编程最核心的理论基础。

全特化与模板的链接方式

首先复习一下我们在开篇时候所提到的一个非常重要的概念。模板本身不是可使用的代码，而是一种代码的升成方法。需要经过实例化后才能成为实际可用的代码。比如说模板函数需要指定模板参数（可以是显式指定，也可以是编译器自动推导）实例化后，才能成为函数，同理，模板类也需要实例化后才能成为类。

然而「全特化」就是说，当所有模板参数都指定了的时候，才叫「全」。那么上一节中add的示例就是一个全特化，因为它原本只有一个模板参数，把它特化了自然是「完全」特化的。

而要谈到全特化，就不得不谈到一个非常容易踩坑的点，那就是模板的链接方式。在一个单独的.cpp文件中使用模板并不会有什么链接性问题，但如果在多个文件中都要使用呢？自然要通过「头文件声明+链接」的方式来完成了。

但模板本身又很特殊，它本身不是可用的代码，而是代码生成器，因此编译器会在编译期用模板来生成代码，注意，这个时候还没有开始链接！所以问题就产生了，假如我们按照直觉和习惯，把模板的声明和定义分文件来写，会怎么样呢？请看下面示例：

tmp.h

#pragma once
template <typename T>
void f(const T &t); // 声明

tmp.cpp

#include "tmp.h"
template <typename T>
void f(const T &t) {} // 实现

main.cpp

#include "tmp.h"
int main() {
  f(1); // f<int>
  f(1.0); // f<double>
  return 0;
}

如果我们真的这么做了，你会发现链接时会报错。原因是这样的，我们在tmp.h中的这种写法，并不是「声明了一个模板函数」，模板函数本不是函数，是不需要声明的，大家记住模板永远是生成代码的工具。所以tmp.h中的写法是「声明了一组函数」，包括我们在main函数中使用的f<int>和f<double>，之所以能通过编译，就是因为tmp.h中存在它们的声明。换句话说，template <typename T> void f(const T&);相当于void f<int>(const int &);,void f<double>(const double &);,void f<char *>(char *const &);……这一系列的「函数声明」。

所以，编译是没问题的，但是链接的时候会报找不到f<int>和f<double>的实现。这是为什么呢？明明我在tmp.cpp中实现了呀！那我们来「换位思考一下」，假如你是编译器，我们知道「编译」过程是单文件行为，那么你现在来编译main.cpp，首先进行预处理，把#include替换成对应头文件内容，那么main.cpp就变成了:

template <typename T>
void f(const T &t);
int main() {
  f(1); // f<int>
  f(1.0); // f<double>
  return 0;
}

上面的f是函数声明，下面编译主函数的时候，根据参数推导出了f<int>和f<double>，于是，通过上面的「模板函数声明」生成了2条实际的「函数声明」语句，也就是：

void f<int>(const int &);
void f<double>(const double &);

调用都是符合声明的，OK，结束编译，我们得到了main.o。

好了，下面我们来编译tmp.cpp。同理，先做预处理，得到了：

template <typename T>
void f(const T &t);
template <typename T>
void f(const T &t) {}

这时，问题的关键点来了！，这个模板函数f在当前这个编译单元中，并没有任何实例化，那么你自然就不知道应当按这个模板来生成哪些实例。所以，你只能 什么都不做，很无奈地生成了一个空白的tmp.o。

最后，main.o和tmp.o链接，main.o中的f<int>和f<double>都找不到实现，所以链接报错。

这就是模板的链接方式问题，由于模板都是编译期进行实例化，因此，必须在编译期就得知道需要哪些实例化，然后把这些实例化后的代码编译出来，再去参与链接，才能保证结果正确。

所以，要保证编译期能知道所有需要的实例，我们只能把模板实现放在头文件里。这样，每一个编译单元都能根据自己需要的实例来生成代码。也就是说，上面的代码应该改造成：

tmp.h

#pragma once
template <typename T>
void f(const T &t);
template <typename T>
void f(const T &t) {} // 当然，文件内部没有声明依赖关系的时候，声明和实现可以合并

main.cpp

#include "tmp.h"
int main() {
  f(1);
  f(1.0);
  return 0;
}

这时，在编译main.cpp时，就会把f<int>和f<double>的实例都编译出来，这样就不会链接报错了。

但这样会引入另一个问题，如果多个.cpp引入同一个含有模板的.h文件，并做了相同的实例化，会不会生成多份函数实现呢？这样链接的时候不是也会报错吗？

设计编译器的大佬们自然也想到这个问题了，那么解决方法就是，通过模板实例出的内容，会打上一个全局标记，最终链接时只使用一份（毕竟是从同一份模板生成出来的，每一份自然是相同的）。再换句更通俗易懂的说法就是模板实例一定是inline的，编译器会给每个模板实现自动打上inline标记，确保链接时全局唯一。

现在我们再回头看一下全特化模板，全特化模板已经是实例化过的了，因此并不会出现编译期不知道要怎么实例化的问题。如果这时我们还把实现放在头文件中会怎么样？

tmp.h

#pragma once
template <typename T>
void f(T t) {} // 通用模板
template <>
void f<int>(int t) {} // 针对int的全特化

t1.cpp

#include "tmp.h"
void Demo1() {
  f(1); // f<int>
}

t2.cpp

#include "tmp.h"
void Demo2() {
  f(1); // f<int>
}

我们再来当一次编译期。首先编译t1.cpp，预处理展开，得到了f<int>的实现，所以把f<int>编译过来，输出t1.o。同理，编译t2.cpp后，也会有一份f<int>的实现在t2.o中。最后链接的时候，发现f<int>重定义了！

因此我们发现，全特化的模板其实已经不是模板了，在这里f<int>会按照普通函数一样来进行编译和链接。所以直接把实现放在头文件中，就有可能在链接时重定义。解决方法有两种，第一种就是我们手动补上inline关键字，提示编译期要打标全局唯一。

tmp.h

#pragma once
template <typename T>
void f(T t) {} // 通用模板，编译器用通用模板生成的实例会自动打上inline
template <>
inline void f<int>(int t) {} // 针对int的全特化，必须手动用inline修饰后才能在编译期打标保证链接全局唯一

第二种方法就是，当做普通函数处理，我们把实现单独抽到一个编译单元中独立编译，最后在链接时才能保证唯一：

tmp.h

#pragma once
template <typename T>
void f(T t) {} // 通用模板
template <>
void f<int>(int t); // 针对int的全特化声明（函数声明）

tmp.cpp

#include "tmp.h"
template <>
void f<int>(int t) {} // 函数实现

之后，f<int>会随着tmp.cpp的编译，单独存在在tmp.o中，最后链接时就是唯一的了。

另外，对于特化的模板函数来说，参数必须是按照通用模板的定义来写的（包括个数、类型和顺序），但对于模板类来说，则没有任何要求，我们可以写一个跟通用模板压根没什么关系的一种特化，比如说：

template <typename T>
struct Test { // 通用模板中有2个成员变量，1个成员函数
  T a, b;
  void f();
};

template <>
struct Test<int> { // 特化的内部定义可以跟通用模板完全不同
  double m;
  static int ff();
}

偏特化

偏特化又叫部分特化，既然是「部分」的，那么就不会像全特化那样直接实例化了。偏特化的模板本质上还是模板，它仍然需要编译期来根据需要进行实例化的，所以，在链接方式上来说，全特化要按普通函数/类/变量来处理，而偏特化模板要按模板来处理。

先明确一个点：模板函数不支持偏特化，因此偏特化讨论的主要是模板类。

我们先来看一个最简单的偏特化的例子：

template <typename T1, typename T2>
struct Test {};
template <typename T>
struct Test<int, T> {};

上面代码就是针对Test模板类，第一个参数为int时的「偏特化」，那么只要是第一个参数为int的时候，就会按照偏特化模板来进行实例化，否则会按照通用模板进行实例化。为了方便说明，我们在通用模板和偏特化模板中加一些用于验证性的代码：

#include <iostream>
template <typename T1, typename T2>
struct Test {
};

template <typename T>
struct Test<int, T> {
  static void f();
};

template <typename T>
void Test<int, T>::f() {
  std::cout << "part specialization" << std::endl;
}

void Demo() {
  Test<int, int>::f(); // 按照偏特化实例化，有f函数
  Test<int, double>::f(); // 按照偏特化实例化，有f函数
  Test<double, int>::f(); // 按照通用模板实例化，不存在f函数，编译报错
}

偏特化模板本身仍然是模板，仍然需要经历实例化。但偏特化模板可以指定当一些参数满足条件时，应当按照指定方式进行实例化而不是通用模板定义的方式来实例化。

那如果偏特化和全特化同时存在呢？比如下面的情况：

template <typename T1, typename T2>
struct Test {}; // 【0】通用模板

template <typename T>
struct Test<int, T> {}; // 【1】偏特化模板

template <>
struct Test<int, int> {}; // 【2】全特化模板

void Demo() {
  Test<int, int> t; // 按照哪个实例化？
}

先说答案，上面的实例会按照【2】的方式，也就是直接调用全特化。大致上来说，全特化优先级高于偏特化，偏特化高于通用模板。

对于函数来说，模板函数不支持偏特化，但支持重载，并且重载的优先级高于全特化。比如说：

void f(int a, int b) {} // 重载函数

template <typename T1, typename T2>
void f(T1 a, T2 b) {} // 通用模板

template <>
void f<int, int>(int a, int b) {} // 全特化

void Demo() {
  f(1, 2); // 会调用重载函数
  f<>(1, 2); // 会调用全特化函数f<int, int>
  f(2.5, 2.6); // 会用通用模板生成f<double, double>
}

回到模板类的偏特化上，除了上面那种制定某些参数的偏特化以外，还有一种相对复杂的偏特化，请看示例：

template <typename T>
struct Tool {}; // 这是另一个普通的模板类

template <typename T>
struct Test {}; // 【0】通用模板

template <typename T>
struct Test<Tool<T>> {}; // 【1】偏特化

void Demo() {
  Test<int> t1; // 使用【0】实例化Test<int>
  Test<Tool<int>>; // 使用【1】实例化Test<Tool<int>>
  Test<Tool<double>>; // 使用【1】实例化Test<Tool<double>>
}

有的资料会管上面这种特化叫做「模式特化」，用于区分普通的「部分特化」。但它们其实都属于偏特化的一种，因为偏特化都是相当于特化了参数的范围。在上面的例子中，我们是针对于「参数是Tool的实例类型」这种情况进行了特化。

所以，偏特化并不一定意味着模板参数数量变小，它有可能不变，甚至有可能是增加的，比如说：

template <typename T1, typename T2>
struct Tool {}; // 这是另一个普通的模板类

template <typename T>
struct Test {}; // 【0】通用模板

template <typename T1, typename T2>
struct Test<Tool<T1, T2>> {}; // 【1】偏特化模板

template <typename T>
struct Test<Tool<int, T>> {}; // 【2】偏特化模板

void Demo() {
  Test<int> t1; // 【0】
  Test<Tool<int, double>> t2; // 【2】
  Test<Tool<double, int>> t3; // 【1】
}

所以偏特化的引入，让模板编程这件事有了爆炸性的颠覆，因为其中的组合可以随意发挥想象。但这里就引入了另一个问题，就比如上例中，【1】和【2】都是偏特化的一种，但为什么Test<Tool<int, double>>选择了【2】而不是【1】呢？这么说，看来不仅仅是跟全特化和通用模板存在优先级问题，多种偏特化之间也仍然存在优先级问题，那么编译器究竟是按照什么方式来进行偏特化匹配的呢？这就是我们下一节要着重研究的问题了。

偏特化模板的匹配优先级

在前面的章节我们提到了多种偏特化的模板的匹配优先级问题，那么当遇到多种偏特化时到底以哪一个为准呢？

这里，匹配优先级的原则是：优先匹配特化程度更高的。那么，怎么理解这个特化程度呢？我们先来举个最简单例子：

template <typename T1, typename T2, typename T3>
struct Test {}; // 【0】

template <typename T1, typename T2>
struct Test<T1, T2, int> {}; // 【1】

template <typename T>
struct Test<T, int, int> {}; // 【2】

void Demo() {
  Test<double, int, int> t; // 匹配【2】而不是【1】
}

上面这个很好理解，因为Test<double, int, int>显然是【2】更加符合这种形式。

那是不是可以理解成，优先匹配参数少的那个呢？未必？请看下面的实例：

template <typename T1, typename T2, typename T3>
struct Test {}; // 【0】

template <typename T1, typename T2>
struct Test<T1, T2, int> {}; // 【1】

template <typename T>
struct Test<int, int, T> {}; // 【2】

void Demo() {
  Test<int, int, int> t; // 匹配哪个？
}

大家可以先猜猜，上面这个例子会匹配哪个。如果按照参数少的来匹配，那应该匹配【2】才对。但实际情况是，哪个都不会匹配，会直接报错。

Ambiguous partial specializations of 'Test<int, int, int>'

所以我们一定要理解那句「特化程度」，它并不以参数个数为评判标准。再来看一个例子：

template <typename T1, typename T2>
struct Test {}; // 【0】

template <typename T1, typename T2, typename T3>
struct Test<T1, T2(T3)> {}; // 【1】

template <typename T>
struct Test<int, T> {}; // 【2】

void Demo() {
  Test<int, int(int)> t; // 会匹配哪个？
}

会匹配哪个呢？答案和上一个例子相同，会报Ambiguous的错误。所以说匹配时更关注的是参数的「形式」，而非个数。拿上面的例子来说，【1】号特化表示的是「第二个参数是一个函数类型，并且函数只有一个参数」的情况；【2】号特化表示的是「第一个参数为int的情况」。所以Test<int, int(int)>也是同时符合了，并没有「程度上」更贴近哪个，所以也会报错。

例子还有很多，这里就不过多列举了，总之，偏特化模板匹配的原则就是「特化程度更高者优先」，如果遇到可以同时命中多种的时候，将会报错（除非有更加匹配的特化，或者有对应的全特化，那么它会优先）。请读者一定要理解这里的「程度」究竟是什么含义。（这里只能说，要去体会了，官方说明文档中有一些比较晦涩的描述，但我更建议大家直接动手写几个例子试一试，会比直接阅读这种规则描述要体会得更快、更彻底一些~）

SFINAE

终于，我们来到了模板元编程前的最后一个基础知识——SFINAE。直接解释SFINAE会有点困难，也会让读者看着一头雾水，所以笔者打算稍后再来解释概念，我们先来看个引子：假如我现在要写一个模板函数，这个函数接收一个参数。最直接的方法就是这样：

template <typename T>
void f(T t) {}

但这样的问题就在于，如果T比较大，或者是一个不可复制的类型，那这样传参就会有问题，这种情况下应当用引用来传参：

template <typename T>
void f(const T &t) {}

但如果改成这样，对于那些基本类型（比如说int、char之类的）来说，是徒增了它的开销（引用本质是指针，所以多了一个指针的空间开销，以及若干取值、解指针的操作开销）。那能不能想个办法，把这两种情况都支持？暂时我们先不考虑是否可拷贝的问题，我们把长度小于等于一个指针大小的类型，用复制的方式传参，大于一个指针大小的类型，用引用传参。怎么做呢？其实方法很多，我们这里介绍一种可以引出SFINAE的方法，先看一下我们现在的诉求：

template <typename T>
void f(T t) {}

template <typename T>
void f(const T &t) {}

// 这里给一个比指针长的类型用来测试
struct Test {
  int arr[16];
};

上面这个例子中，我们写了2个同名的模板函数f，但我们希望针对一个确定的T时，只会按照其中的一个进行实例化。比如说f<int>就用第一种实例化，f<Test>就用第二种实例化。

但假如不加任何限制的话，编译器就会把两个f都进行实例化，比如说f<int>就会同时生成一组重载函数：

void f<int>(int t);
void f<int>(const int &t);

那么这时候我们再调用比如说f<int>(1)的时候，就会报错，因为两种函数原型都可以命中。

那如何让它只选其中的一个来生成实例呢？这需要我们用一个辅助类来完成：

template <typename T, bool Cond>
struct EnableIf {};

template <typename T>
struct EnableIf<T, true> {
  using type = T;
};

template <typename T>
void f(typename EnableIf<T, sizeof(T) <= sizeof(void *)>::type t) {
  std::cout << 1 << std::endl;
}

template <typename T>
void f(typename EnableIf<T, (sizeof(T) > sizeof(void *))>::type const &t) {
  std::cout << 2 << std::endl;
}

void Demo() {
  f<int>(1); // 打印1
  Test t;
  f<Test>(t); // 打印2
}

上面例程中，我们使用了一个辅助类EnableIf，接收两个参数。大家注意看第二个参数，是一个布尔类型，我们针对于第二个参数为true的情况进行了偏特化，此时把T透传出来。那么也就是说，第二个参数为true的时候，才存在type这个成员，而false时会命中通用模板，此时是没有type这个成员的。

然后我们在两个模板函数f中都使用了typename EnableIf::type，只是第二参数传入的条件不同。那么这个时候编译器会怎么做呢？这就是模板实例化时的一个核心环节——匹配（Substitution）。

所谓的「匹配」就是指，编译器会拿着实参去尝试实例化，比如，实例化f<int>的时候，编译器会先尝试用第一个模板函数来实例化，也就是变成了：

void f(typename EnableIf<int, sizeof(int) <= sizeof(void *)>::type t);

然后这里的判断条件是符合的，所以替换为true：

void f(typename EnableIf<int, true>::type t);

这时会去实例化EnableIf<int, true>，命中了它的偏特化，里面是有type的，而typename EnableIf<int, true>::type就是int，所以这里就变成了：

void f(int t);

没什么问题，于是编译器就按照这个模板生成了f<int>函数，函数原型是void f<int>(int)。我们称这个过程为「匹配成功（Substitution Success）」。

那对于f<Test>呢？同理，也会发生类似的过程。首先，按照第一个模板参数来尝试实例化：

void f(typename EnableIf<Test, sizeof(Test) <= sizeof(void *)>::type t);

然后判断条件不符合，所以替换为false：

void f(typename EnableIf<Test, false>::type t);

接下来实例化EnableIf<Test, false>，没有命中偏特化，因此要用通用模板来实例化。但EnableIf<Test, false>中并没有type这个成员。因此，typename EnableIf<Test, false>::type这个表达就是个错误的表达，无法用它来实例化。我们把这个过程称之为「匹配失败（Substitution Failure）」。

注意，重点来了！！虽然匹配失败了，但这时编译器并不会立刻报错，而是会继续尝试匹配其他的模板，因为我们还有一个模板函数f还没尝试呢！于是，编译器会继续用第二个模板尝试实例化：

void f(typename EnableIf<Test, sizeof(Test) > sizeof(void *)>::type const &t);

变成：

void f(typename EnableIf<Test, true>::type const &t);

同理，命中了偏特化，此时typename EnableIf<Test, true>::type就是Test，所以变成了：

void f(Test const &t);

没问题，于是按照这个模板进行实例化，函数原型是：void f<Test>(Test const &t)。

因此，编译器在实例化模板时，如果遇到多个同名模板，则会逐一「尝试」匹配，在这个过程中如果发生了失败，并不会马上报错，因此把这种特性称之为「匹配失败不是错误（Substitution Failure Is Not An Error，简称SFINAE，我个人为了方便会直接读成/'sfɪni:/，但这个不是规范哈，依次按照字母读是绝对OK的！）」。

这里我们写的EnableIf其实就是STL中提供的std::enable_if的一个简化版。SFINAE是模板元编程最重要的理论基础，整个静态推导都是基于「构造一种模式，让其匹配成功或者失败」的方式来进行的。

模板元编程

STL中提供的工具

从这一章开始，我们将正式介绍模板元编程。在STL中已经提供了很多静态的工具可供使用，模板元编程过程中自然少不了使用这些工具。当然，由于我们是模板元编程的详细教程，因此我也会带着大家来手写这些工具的源码。

需要注意的是，并不是所有的工具都是能手撸出来的，有极个别工具的底层实现依赖于编译器的“魔法操作”，真的遇到了那我们也没办法，其余能够手撸的，笔者都会介绍其手 动实现方法。

STL中提供的模板元主要收纳在type_traits头文件中，有兴趣的读者可以查看官方的API参考文档。

模板元编程的两个要素

在上一节，我们引出了std::enable_if的用法，开启了模板编程的新纪元。STL中的std::enable_if跟我们上一节写的demo还是稍微有一点区别的，下面是它的实现：

template <bool cond, typename T = void>
struct enable_if {};

template <typename T>
struct enable_if<true, T> {
  using type = T;
};

从这个模板元的元老中可以看出，它有2个要素，一个是用于静态判断的cond，另一个是用于类型处理的T。所以，模板元编程无非就是做两件事，一个是静态数学计算（包括了布尔类型的逻辑运算和整数类型的数值运算。这里的「静态」是指编译期行为。）；另一个是类型处理（type traits，也被翻译为「类型萃取」）。

所以，静态计算和类型处理的编写过程，就称为「模板元编程」。把这两个要素的结果放到enable_if（或类型行为的模板）中，再通过SFINAE特性生成需要的代码再去参与编译。

强调一下，模板元编程是完完全全的编译期行为，任何设计运行期才能确定的数据都不可用，因此我们的编程思维跟普通代码编写的思维也是完全不同的，请读者一定要注意。

静态计算

静态计算主要有整数运算（C++20起也支持浮点数运算了）和逻辑运算。其中逻辑运算是重点，也是我们在模板元编程中最常用到的静态计算。下面分别来介绍。

整数运算

静态的整数运算在模板元编程中并不是特别常用，类似于数组元素个数这样的静态参数，往往在编写的时候都是确定好的，并不需要做额外的运算，即便是做了，可能也就是+1这种非常简单的运算，笔者在这里就不着重来介绍了。

我们看一个真正意义上使用静态整数运算的例子。假如我要在程序中用到斐波那契数列的第30项。注意！我只用它的第30项，30这个数是静态确定的，并不是程序的输入。我应该怎么做？

相信有读者会说，「嗨！这还不简单！写个计算的函数不就好了嘛！」

uint64_t Fib(uint16_t n) {
  if (n == 0 || n == 1) {
    return 1;
  }
  return Fib(n - 2) + Fib(n - 1);
}

void Demo() {
  std::cout << Fib(30) << std::endl;
}

这样做肯定是正确的，但仔细想想，Fib这个函数会跟随程序编译成一段指令，每次程序运行的时候，都会执行这段指令，现场算出Fib(30)，再打印出来。但斐波那契数列第30项它就是一个固定值呀！何必每次都要现算呢？

给出这样的提示，相信又会有读者会说，「哦，那我知道了！我先手算一遍，第30项应该是1346269，所以直接用这个值去替换」。

void Demo() {
  std::cout << 1346269 << std::endl;
}

非常好！如果你能想到这里，那离成功已经近一大步了！这里的1346269就是个固定值，斐波那契数列第30项无论什么时候都是这个值，不需要再去计算。可直接这样写上去一个魔数会让程序可读性变差，所以我们应该搞一个名字给它：

uint64_t fib_30 = 1346269;
void Demo() {
  std::cout << fib_30 << std::endl;
}

可读性是有了，但这样会引入另一个问题，fib_30是一个全局变量，既然是变量，它就是占内存空间的，并且会在主函数执行之前对其进行初始化。换句话说，上面的程序变成了，一开始先分配一片内存空间，把1346269这个值写进去，等后面需要用的时候，读取这片内存空间。

看得出，这片内存空间也是多余的，还是那句话，1346269这个值永久不变，编译期就应该确定，因此我们要再优化一下，让编译器用常量的方式来处理它：

constexpr uint64_t fib_30 = 1346269; // 这里换成宏定义也是一样的效果
void Demo() {
  std::cout << fib_30 << std::endl;
}

好，上面的需求我们解决了。那假如，这时我除了要用第30项以外，还要用第18、21、24和28项，怎么办？嗯，都算出来写上去肯定是一种方法：

constexpr uint64_t fib_18 = 4181;
constexpr uint64_t fib_21 = 17711;
constexpr uint64_t fib_24 = 75025;
constexpr uint64_t fib_30 = 1346269;

void Demo() {
  std::cout << 18 << "->" << fib_18 << std::endl;
  std::cout << 21 << "->" << fib_21 << std::endl;
  std::cout << 24 << "->" << fib_24 << std::endl;
  std::cout << 30 << "->" << fib_30 << std::endl;
}

但这时我们就发现了，这不是长久之计，毕竟咱不可能在程序里穷举出所有的数列的项，更何况像数值计算这种事怎么能是人工手算呢？万一算错一个数字都会有问题。我们要的效果是，在程序运行之前，就把需要的数列项的值计算好，而在程序运行的时候，这些值就是常数值了。因此，这就需要用到静态的数值计算。

编写的思路同样是递归，只不过要用模板元编程的方式，让所有的数值计算变为静态期。请看例程：

template <uint16_t N>
struct Fib {
  constexpr static uint64_t value = Fib<N - 2>::value + Fib<N - 1>::value;
};
template <>
struct Fib<0> {
  constexpr static uint64_t value = 1;
};
template <>
struct Fib<1> {
  constexpr static uint64_t value = 1;
};
void Demo() {
  std::cout << 18 << "->" << Fib<18> << std::endl;
  std::cout << 21 << "->" << Fib<21> << std::endl;
  std::cout << 24 << "->" << Fib<24> << std::endl;
  std::cout << 30 << "->" << Fib<30> << std::endl;
}

这里把Fib定义为一个模板类，其成员value是一个静态量，表示对应的数列项的值。通用模板中定义其为前两项的和，然后把第0项和第1项单独特化出来。这样一来，我们就实现了完全编译期计算的目的。

这样做的好处不仅仅是提升程序的运行性能，还可以把计算的值用做其他模板元。比如说，我希望定义一个数组，它的元素个数是斐波那契数列的第10项，那么就可以写成：

void Demo() {
  std::array<int, Fib(10)> arr; // Fib(10)是编译期可确定的值，因此可以传递
}

而这种情况如果是动态计算出的值，则无法作为函数参数传递，也就是说，下面这种写法是非法的：

uint64_t fib(uint16_t n) {
// 省略实现
}

void Demo() {
  std::array<int, fib(10)> arr; // 非法，因为fib(10)不是编译期可确定的值
  int arr2[fib(10)]; // 同理非法（有的编译器可能会优化容错使这种写法通过编译，但按语言标准来说，这种写法是非法的）
}

然而，在程序中用到数列的某一项这种需求其实几乎不存在，我们也仅仅是在讲解知识点的时候用做示例。真正在模板元编程中起作用的静态数值计算，其实是用于生成序列的功能。笔者将会在后续章节详细介绍生成序列的方法以及其用途。

逻辑运算

静态逻辑运算不单单是对数值做逻辑判断（比如说N>0这种），在模板元编程中，更多的是对「类型」进行是非判断。下面举一些例子可能更容易说明。

简单的静态判断

假如我希望判断当前类型是否是某一类型，如何来做？这里我们仍然是利用偏特化，下面例程用于展示，判断T1和T2是否是同一类型：

template <typename T1, typename T2>
struct is_same {
  constexpr static bool value = false;
};

template <typename T>
struct is_same<T, T> {
  constexpr static bool value = true;
};

// 下面是一个demo，利用enable_if，当参数为int时才生效
template <typename T>
typename std::enable_if<is_same<T, int>::value, void>::type
f(T t) {
}

上面例子本身很好理解，就不过多啰嗦了。不过不知道大家是否能发现，在处理这些静态逻辑判断时，使用的这些工具类，都会有一个静态的成员常量，我们这里叫value。当然了，实际上你把它叫什么名字都不影响使用，只不过在模板元编程中，我们倾向于符合STL当中的规范，使用value这个名字。

另一点就是，像上面这样把value展开来写会比较长，容易出错，也降低了一些可读性。在STL当中，把计算属性的部分抽象出了一个基类，同时，又给布尔类型的实例起了别名，就像下面这样：

template <typename T, T val> // 注意这里的写法
struct integer_constant {
  constexpr static T value = val;
};

// 对布尔类型的实例单独起名
template <bool val>
using bool_constant = integer_constant<bool, val>;

那么上一节讲到的斐波那契数列前两项的特化就可以改写成：

template <>
struct Fib<0> : std::integer_constant<uint64_t, 1> {};

template <>
struct Fib<1> : std::integer_constant<uint64_t, 1> {};

就避免了展开去写容易出错且可读性低的问题。

同时，由于布尔类型只有true和false两个取值，因此bool_constant<true>和bool_constant<false>也被单独定义了出来：

using true_value = bool_constant<true>;
using false_value = bool_constant<false>;

这样一来，我们改写一下前面的is_same：

template <typename T1, typename T2>
struct is_same : false_value {};

template <typename T>
struct is_same<T, T> : true_value {};