0.0 一些深度理解，必须提前知道#

• 只有函数模板（function template), 没有模板函数（templated function)。类模板同理

• 函数（主）模板并不是函数。函数模板没有类似于函数的行为。类模板同理

  • 函数主模板本身并不能调用。
  • 我们表面上是调用了函数主模板，但是实际上是编译器推导出（或我们自己指定出）类型后，编译器将所有的T替换为对应类型。然后合成出来的一个新的实例。这就是实例化。
  • 所以，函数主模板本身从不是重载决议候选人（candidate）。候选人是编译器帮助我们替换了T之后的实例化的函数。

https://youtu.be/NIDEjY5ywqU

• 编译器会通过函数的（主）模板，合成（synthesize）一个特化的函数声明（declaration）[其实是签名signature]。然后实例化（instantiate)这个函数的定义（definition）。
  • 它会首先检验函数的调用，通过查看传入的参数或显式指定的参数获取类型。
  • 然后替换所有的占位符T
  • 最后我们得到了一个用于重载决议的候选对象，也就是个函数。

0.1 部分名词解析#

• 我们知道编译器处理模板代码的时候会进行替换，也就是把每一个T替换成传入的模板参数。这个过程被称之为模板的实例化（ instantiation）
• 一旦我们有了实例化的动作，我们就拥有了一个函数。这个函数被称之为特化（specialization）。在这个时候，T已经被替换为对应类型。特化是特定于类型的。他们关心类型，现在不再是类型不可知得了。类模板也一样
• 特化过的类模板或函数模板，或说编译器已经通过类模板和函数模板合成出来的附带了特定类型的类或函数的行为和普通的类和函数是一致的。
• 但是我们依旧可以使用<>来显式指定一个被关联到模板参数的、被进行了特殊替换的声明。比如这样：
  • 为了区分编译器帮助我们进行的特化，针对这种情况，我们称之为显式(全)特化(explicit specialization)
  • 一般来讲，显式特化被认为是通用模板的一种特殊形式。

1
template<typename T1, typename T2> // 主模板
2
class MyClass {
3
    //一些内容
4
};
5
template<> // 显式全特化。
6
class MyClass<std::string,float> {
7
    //一些内容
8
};

• 如果在显式全特化后，仍需要添加一些模板参数，我们就称之为[显式]部分特化（偏特化）

1
template<typename T> // 偏特化
2
class MyClass<T,T> {
3
    //一些内容
4
};
5
template<typename T> // 偏特化
6
class MyClass<bool,T> {
7
    //一些内容
8
};

0.2 显式实例化（14.5），隐式实例化和特化。#

1
template<typename T>
2
void func(T a){
3
    cout << a << endl;
4
}
5

6
template
7
void func<float>(float a); //2 显式实例化
8

9
template
10
void func<>(int a); //也可以
11

12
int main(){
13
    func(10); //1 隐式实例化
14
    func<int>(10); //也叫隐式实例化。没错，显式指明模板参数会导致隐式实例化。
15
    return 0;
16
}

1. 这个过程叫做隐式实例化。隐式实例化指的是函数或类模板被使用或调用的时候，由编译器帮助我们处理的过程。因为编译器帮助我们合成了这个函数的声明，实例化了函数的定义。这个func(10)本身是一个特化的函数。
2. 这个过程叫做显式实例化，也叫做外部实例化。显示实例化的意义在于在不发生函数调用的时候就已经将函数模板实例化，或者在不使用类模板的时候就已经将类模板实例化称之为模板显示实例化。这个void func<float>(float a)函数本身也是一个特化的函数。
   • 显式实例化只需要写声明，不需要写定义。也就是我们通知编译器，直接根据这个声明，实例化这个函数定义。

• 无论是编译器帮助我们合成后实例化的，还是我们自己显式特化的，只要这个函数有了明确的类型要求，这就是一个特化的函数。（和函数模板相比）
• 显式特化在上一节。
• 显示实例化和显式特化的语法区别在于显式实例化的template关键字后不加<>，显式特化的template关键词后要加<>
• 当一个函数模板被定义在一个头文件中且被多个源文件包含时，每个包含该头文件的源文件都会产生模板的实例化。通常情况下，因为模板是内联的，这不会导致链接错误。然而，如果你显式地实例化了模板函数或者类模板，则可能会遇到链接问题。显式实例化告诉编译器在给定的翻译单元（通常是一个.cpp文件）中创建模板的具体实现。如果在多个源文件中进行了相同模板的显式实例化，那么链接器将报告重复定义错误。当然了, 如果使用了显式实例化, 则在其他需要用到该模板的地方需要使用外部模板声明.

1
extern template void func<int>(int a);

extern 模板声明用于防止模板在当前翻译单元中被实例化. 这种情况下, 该函数的调用不会导致模板在当前翻译单元中实例化, 因为已经在外部单元实例化过了.

显示实例化的各种方式, 详细例子, 和优缺点分析

1
#pragma once
2
#include <iostream>
3
struct f {
4
    template <typename T>
5
    void ReallyBigFunction();
6
};
7

8
template<typename T>
9
void f::ReallyBigFunction(){
10
    std::cout << "ReallyBigFunction" << std::endl;
11
}
12

13
// b.cpp
14
#include "a.h"
15
#include "iostream"
16

17
extern template void f::ReallyBigFunction<int>(); // 注意这里
18
void something1()
19
{
20
    f o;
21
    o.ReallyBigFunction<int>();
22
}
23

24
// c.cpp
25
#include "a.h"
26
#include "iostream"
27

28
void something2()
29
{
30
    f o;
31
    o.ReallyBigFunction<int>();
32
}
33

34
int main(){
35

36
}

1
#pragma once
2
#include <iostream>
3
struct f {
4
    template <typename T>
5
    void ReallyBigFunction();
6
};
7

8
// a.cpp
9
#include "a.h"
10
#include <iostream>
11

12
template<typename T>
13
void f::ReallyBigFunction(){
14
    std::cout << "ReallyBigFunction" << std::endl;
15
}
16

17
template void f::ReallyBigFunction<int>();

0.3 声明和定义#

我们在杂记当中已经解释了什么是声明和定义，这里针对上下文再次强化一下认知：

• “声明”将一个名称引入或者再次引入到一个 C++作用域内。引入的过程中可能会包含这个名称的一部分类别，但是一个有效的声明并不需要相关名称的太多细节。比如：

1
class C; // 类C的声明
2
void f(int p); // 函数f的声明
3
extern int v; // 变量v的声明。注意这里使用了extern

• 对于声明 ,如果其细节已知, 或者是需要申请相关变量的存储空间，那么声明就变成了定义。
  • 对于 类类型的定义和函数定义，意味着需要提供一个包含在{}中的主体，或者是对函数使用了=defaut/=delete。
  • 对于变量，如果进行了初始化或者没有使用 extern，那么声明也会变成定义。下面是一些“定义”的例子：

1
class C {}; // 声明并定义 类C
2
void f(int p) { //声明并定义函数f
3
  std::cout << p << ’\n’;
4
}
5
extern int v = 1; // 因为初始化了，所以这里也是声明并定义了变量v
6
int w; // 全局变量，就算没有初始化，由于没有使用extern，所以也是声明并定义变量w

• 如果一个类模板或者函数模板有包含在{}中的主体的话，那么声明也会变成定义。所以

1
template<typename T>
2
void func (T); //这个是声明。
3

4
template<typename T>
5
class S {}; //这个是定义。

0.4 模板形参和模板实参#

1
template<typename T1> // T1 是模板形参，形式上的参数。 parameter
2
class test;
3
int main(){
4
  test<int> obj; //int 是模板实参，实际传入的参数。 argument
5
}

简单来讲可以说：模板参数是被模板实参初始化的。或者更准确的说：

• 模板参数是那些在模板定义或者声明中，出现在 template 关键字后面的尖括号中的名称。
• 模板实参是那些用来替换模板参数的内容。不同于模板参数，模板实参可以不只是名称。

0.5 模板名（template-name) 和 模板标识（template-id)#

• 模板名，顾名思义就是模板的名字。如下面例子的Demo就是模板名。
• 模板标识，是模板名和其参数列表。也就是整个模板名<形参列表>是一个模板标识。下面的Demo<int>就是模板标识。

1
template <typename T>
2
struct Demo{
3
    // ...
4
};
5

6
int main()
7
{
8
   Demo <int> d; // Demo 是 template name, Demo<int> 是 template-id
9
   // ...
10
}

https://zh.cppreference.com/w/cpp/language/templates

https://stackoverflow.com/questions/3796558/difference-between-template-name-and-template-id

• 当指出模板的模板标识 的时候，用模板实参替换模板参数的过程就是显式的，但是在很多情况这一替换则是隐式的（比如模板参数被其默认值替换的情况。一个基本原则是：任何模板实参都必须是在编译期可知的。就如接下来会澄清的，这一要求对降低模板运行期间的成本很有帮助。由于模板参数最终都会被编译期的值进行替换，它们也可以被用于编译期表达式。

0.6 不推导语境#

因为比较分散，所以请在笔记内搜索关键词： 不推导语境

1.1.2 基本信息#

• 在声明模板变量类型的时候，尽量使用typename而非class。尽管没有区别。

• 所有的模板类型参数都应该可以被推导或有默认值。不应该无法推导的模板参数，会导致错误。（个人推理）

• 函数模板有两种类型的参数：

  • 模板参数：位于函数模板名称的前面，在一对尖括号内部进行声明：

  1
  template <typename T>　　　　　　 //T是模板参数
  

  • 调用参数：位于函数模板名称之后，在一对圆括号内部进行声明：

1
T max (T const& a, T const& b)　　 //a和b都是调用参数

• 一定要让函数模板的所有重载版本的声明都位于它们被调用的位置之前（一般都放在同一个头文件中）

1
template<typename T>
2
void foo(T t)
3
{
4
  undeclared(); // 如果 undeclared()未定义，第一阶段就会报错，因为与模板参数无关
5
  undeclared(t); //如果 undeclared(t)未定义，第二阶段会报错，因为与模板参数有关
6
  static_assert(sizeof(int) > 10,"int too small"); // 与模板参数无关，总是报错
7
  static_assert(sizeof(T) > 10, "T too small"); //与模板参数有关，只会在第二阶段报错
8
}

1.2 函数模板参数类型推断#

没啥特别要说的，注意两点：

• 一个是模板形参是万能引用T&&的时候触发的引用折叠。
• 另一个是利用函数参数自动推导出的模板参数右值引用，只可能推导出左值引用或者基本类型。这点看下面的推导表格就能发现，T永远不会被推导成&&。都是推导成非引用或左值引用版本，然后和T后附加的&或&&形成引用折叠
  • 注意是永远不会推导出而不是永远不会成为。这也说明了为什么std::forward在一般情况下触发的都是左值版本，除非显式指明为右值引用如forward<int&&>(5)。参考杂记1

1
template<typename T>
2
struct typewrapper{
3
    typewrapper(T args){
4

5
    }
6
};
7
void foo(typewrapper<tmp> f){
8
    std::puts(__PRETTY_FUNCTION__);
9
    cout <<"called" << endl;
10
}
11
template<typename... T>
12
void foo0(typewrapper<T...> f){
13
    std::puts(__PRETTY_FUNCTION__);
14
    cout <<"called" << endl;
15
}
16

17
void foo1(function<void(int, int, int)>){
18
    cout <<"called" << endl;
19
}
20
template<typename... Args>
21
void foo2(function<void(Args...)>){
22
    cout <<"called" << endl;
23
}
24

25

26
template<typename... Args>
27
void foo3(Args... F ){
28
    cout <<"called" << endl;
29
}
30
int main(){
31
    foo(typewrapper<tmp>(tmp{}));
32
    foo(tmp{});
33

34

35
    foo0(typewrapper<tmp>(tmp{}));
36
    foo0(tmp{}); //不行
37

38
    foo1(function<void(int, int, int)>(callablefunc));
39
    foo1(callablefunc);
40

41
    foo2(function<void(int, int, int)>(callablefunc));
42
    foo2(callablefunc); //不行
43

44
    foo3(function<void(int, int, int)>(callablefunc));
45
    foo3(callablefunc); //可以
46
}

1
template <typename T>
2
void func(T a, T b){
3
    cout <<"success" << endl;
4
}
5
int main() {
6
    long lng = 2000;
7
    func<int>(lng, 2); //显式指定模板实参类型
8
}

1
func(lng, 2);//不行。一个是long一个是int。但是只有一个T类型
2
func<int>(lng, 2); //可以。显式指定T为int，lng被隐式转换了。

1
template<typename T>
2
void func(T a = 12){
3
    cout << "called" << endl;
4
}
5
int main(){
6
    func(1); //OK 没问题 推导为int
7
    func(); //编译器发出抱怨，甚至想骂人。
8
    return 0;
9
}

1
template<typename T = int> //注意这里
2
void func(T a = 12){ //这里
3
    cout << "called" << endl;
4
}
5
int main(){
6
    func(); //OK
7
    return 0;
8
}

1.3 多个模板参数#

好像是废话，但是水还是蛮深的。我们一起看一下。

1
template<typename T1, typename T2>
2
T1 func(T1 a, T2 b){
3
    return b < a ? a : b;
4
}
5
int main(){
6
    auto ret = func(1,2.345);
7
    return 0;
8
}

• 看上去就和我们想的一样，它可以接受两个不同类型的调用参数。但是如示例代码所示，这也导致了一个问题:
  • 如果你使用其中一个类型参数的类型作为返回类型，不管是不是和调用者预期地一样，当应该返回另一个类型的值的时候，返回值会被做类型转换。这将导致返回值的具体类型和参数的传递顺序有关。
  • 例子：如果传递 2.345 和 1 给这个函数模板，返回值是 double 类型 的 2.345，但是如果传递 1 和 2.345，返回值却是 int 类型的 2。因为我们固定返回较大的数字。但是返回值类型会被进行隐式转换。

所以我们有三个方法解决这个问题：

1. 引入第三个模板参数作为返回类型。
2. 让编译器找出返回类型。
3. 将返回类型定义为两个参数类型的“公共类型。

1
template<typename RT, typename T1, typename T2>
2
RT func(T1 a, T2 b){
3
    cout << "called" << endl;
4
}

1
template<typename RT, typename T1, typename T2>
2
RT func(T1 a, T2 b){
3
    cout << "called" << endl;
4
}
5
int main(){
6
    func<int>(1,2.345); //注意。后面两个可以省略。因为可以被推导。
7
    return 0;
8
}

1
template<typename T1, typename T2> //不使用尾置返回类型
2
auto func(T1& a, T2& b){
3
    return b < a? a: b;
4
}
5

6

7
template<typename T1, typename T2> //使用尾置返回类型
8
auto func(T1& a, T2& b) -> decltype(b<a? a:b){
9
    return b < a? a: b;
10
}

1
auto (*fp)() -> auto = f;

1.4 模板默认参数#

• 可以在模板默认参数中使用common_type或者是decay来获取默认值。比如

1
template<typename T1, typename T2, typename RT = std::decay_t<decltype(true ? T1() : T2())>>
2
//也可以这样typename RT = std::common_type_t<T1,T2>>
3
RT max (T1 a, T2 b){
4
return b < a ? a : b;
5
}

• 和函数默认值不同，在函数模板参数中，即使后面的模板参数没有默认值，我们依然可以让第一个模板参数有默认值。并且此时调用时可以不显式指定<>

1
template<typename RT = int, typename T1, typename T2>
2
RT func(T1 a, T2 b){
3
    return a;
4
}
5
int main(){
6
    auto c = func(1,2.234); //并且此时调用时可以不显式指定<>
7
    return 0;
8
}

1.5 函数模板重载和显式全特化#

像普通函数一样，函数模板也是可以重载的。也就是说，你可以定义多个有相同函数名的函数，当实际调用的时候，由 C++编译器负责决定具体该调用哪一个函数。即使在不考虑模板的时候，这一决策过程也可能异常复杂。

• 和普通函数一样，函数模板可以被重载。不止可以被重载，还可以进行特化。但是函数模板只能全特化。

  • 决议顺序：普通函数 > 主模板（未特化的模板） > 全特化版本。因为越特化的可能越是需要的
    • 当两个都为模板版本，则调用更特化的模板函数
    • 因为越特化的可能是越实际要求的。

• 如果函数名指名了某个函数模板，那么首先进行模板实参推导
• 如果它成功，那么将会生成一个单独的模板特化并添加到所要考虑的重载集合中。
  • 这一步骤结合0中提到的，通过函数模板合成一个函数，然后添加进重载决议候选人集合中
• 如果集合中有多于一个函数与目标匹配，且至少一个函数是非模板，那么从考虑集合中去除模板特化。
  • 这一步是普通函数优先于模板合成出的函数。
• 如果所有剩余候选者都是模板特化，那么当存在更特殊的模板特化时，移除较不特殊者。如果在各项移除之后还有多于一个候选者，那么程序非良构。
  • 这一步是如果剩余的函数都是模板函数，那么最特化的优先。如果在这之后还是多个函数，则会有隐含问题。

关于重载决议和匹配，写在文末。

• 如果函数模板和普通函数都可以实现（同名的函数模板可以被实例化为与非模板函数具有相同类型的调用参数），在所有其它因素都相同的情况下，优先调用普通函数而不是从模板实例化出来的函数。

• 如果模板可以实例化出一个更匹配的函数，那么就会优先调用模板函数。（！！！！！！比如如果普通函数涉及到任何级别的类型转换的时候，如果模板能直接合成出一个完美匹配的函数模板，则此时会调用模板合成的函数！！！！！！）

• 可以使用空模板参数列表<>来强制调用函数模板

• 在模板参数推断时不允许自动类型转换，而常规函数是允许的。

• 当有多个特化的函数模板可以被匹配的时候，会有二义性导致报错。

• 函数模板显式全特化不能包含默认实参值。然而，对于被特化的模板所指定的任何默认实参，显式特化版本都可以应用这些默认实参值（其参数默认值会被保留）。

1
template<typename T>
2
T f(T a, T b = 42)
3
{
4
    cout <<"general" << endl;
5
    cout << b << endl;
6
    return b;
7
}
8
template<>
9
float f <float>(float a, float b = 42.2) // 错误
10
{
11
    cout <<"special" << endl;
12
    cout << b << endl;
13
    return b;
14
}
15
template<>
16
double f <double>(double a, double b) // 可以
17
{
18
    cout <<"special" << endl;
19
    cout << b << endl;
20
    return b;
21
}
22
f(4); //输出general 42
23
f(4.444); //输出special 42

• ！！！注意，只有非模板和主模板重载参与重载决议。显式全特化并不是重载也从不参与重载决议，因此此时不受考虑。只有在重载决议选择最佳匹配的主函数模板后，才会考虑它的全特化版本以查看最佳匹配者。
  • 因为显式全特化的函数模板没有独立名称。也就是不引入名称。因为它只是一个替换的定义，而不是一个替换的声明。
  • 显式全特化不是重载。

1
template<class T>
2
void f(T);    // #1：所有类型的重载
3
template<>
4
void f(int*); // #2：#1 的特化，针对指向 int 的指针
5
template<class T>
6
void f(T*);   // #3：所有指针类型的重载
7

8
f(new int(1)); // 调用 #3，虽然 #1 的特化是完美匹配

1
void test(int a, int b){
2
    cout << "普通函数" << endl;
3
}
4

5
template <typename T>
6
void test(T a, T b){
7
    cout << "模板函数" << endl;
8
}
9

10
template <typename T>
11
void test(T a, T b, T c){
12
    cout << "重载的模板函数" << endl;
13
}
14
template<>
15
void test<int>(int a, int b, int c){
16
//void test(int a, int b, int c){ //可以去掉 <int>
17
    cout <<"全特化" << endl;
18
}
19
int main(){
20
    test(1,2); //输出普通函数
21
    test<>(1,2); //使用空模板参数列表 输出模板函数
22
    test(1.1,2.2,3.3); //输出重载的模板函数
23
    test(1,2,3); //输出全特化
24
    test<int>(1,2,3); //输出全特化
25
    return 0;
26

27
}

• 为什么后两个都输出全特化？因为他们都是int。多个候选者都为模板的时候，更特化的优先。

  • 目前只有两个模板可以接受三个参数。而此时int可以匹配到下面的全特化版本，所以全特化版本优先。

• 倒数第三个因为是float。这样由于模板匹配的优先级大于类型转换。所以会被匹配到重载的模板函数。

• 通常而言，在重载模板的时候，要尽可能少地做改动。你应该只是改变模板参数的个数或者显式的指定某些模板参数。比如不要一会儿值传递一会儿引用传递。

• 函数的全特化是非常不好的设计。全特化提供的是一个替换的定义，而不是一个替换的声明。在调用函数模板的时点，该调用已经完全基于函数模板而完成解析了 [16.3.2]。所以：

  • 无法在没有主模板的时候对函数模板进行全特化。

    • 再次重申全特化的函数没有新的mangled的名字。也就是全特化函数没有独立名字。

  • 类成员函数的全特化必须写在类外。

• 如果是分文件编译，为了预防重定义导致的链接错误，必须把全特化的函数模板定义为inline防止重定义。

  • 因为在链接器的眼里，函数模板在全特化之后和常规函数是一样的。

1
//允许参数顺序（因为类型顺序不同）不同
2
template<typename T1,typename T2>
3
void func(T1, T2){
4

5
}
6
template<typename T1,typename T2>
7
void func(T2, T1){
8

9
}
10
//允许返回值类型不同
11
template<typename T1>
12
int func1(T1){
13

14
}
15
template<typename T1>
16
char func1(T1){
17

18
}
19

20
//允许模板形参个数不同，允许函数形参个数不同
21
template<typename T1,typename T2>
22
void func2(T1, T2){
23
    cout <<"2 typename" << endl;
24
}
25
template<typename T1>
26
void func2(T1, T1){
27
    cout <<"1 typename " << endl;
28
}
29
template<typename T1>
30
void func2(T1){
31
    cout <<"single param" << endl;
32
}

所谓的类型转换和模板参数推导的关系#

我们之前说过, 在模板参数推断时不允许自动类型转换，而常规函数是允许的。

1
template<typename T>
2
void func(T A, T B){
3
    std::puts(__PRETTY_FUNCTION__);
4
}
5
int main(){
6
    func(123.1, 2); //不可以
7
    func<int>(123.1, 2);  //可以
8
    return 0;
9
}

但是为什么上面的第二种就可以呢？

关键在于 在模板参数推导时不允许隐式类型转换。也就是当推导T的过程中，如果发现类型不匹配，不允许在这个时候发生隐式类型转换（把参数换成其他类型）。原因之前提到过，也就是类型转换是重载决议负责的，而不是参数推导负责的。所以第一种不可以，因为推断的时候通过第一个参数推断出T是double，但是第二个参数推断出T是int，发生了冲突，而此时不可以把第二个参数类型隐式转为double。

为什么第二行可以呢？是因为我们指明了模板参数。这个时候相当于跳过了推导这一阶段，因为我们通过显式指定模板参数的方式隐式实例化了对应函数。然后进行重载决议的时候就可以进行类型转换了。所以：

1
template<typename T>
2
struct typewrapper{
3
    typewrapper(T args){
4
        cout <<"const" << endl;
5
    }
6
    operator T(){
7
        cout <<"converted" << endl;
8
        return T();
9
    }
10
};
11
class tmp{
12
    public:
13
    string _text;
14
    tmp() = default;
15
    tmp(string c): _text(c) {}      //单参构造，可以看做转换构造
16

17
};
18
template<typename T>
19
void foo3(T A, T B){
20
    std::puts(__PRETTY_FUNCTION__);
21
    cout <<"called" << endl;
22
}
23

24
int main(){
25
    foo3<typewrapper<tmp>>(typewrapper<tmp>{tmp{}}, tmp{}); //可以
26
    foo3<tmp>(typewrapper<tmp>{tmp{}}, tmp{}); //可以
27
    foo3(typewrapper<tmp>{tmp{}}, tmp{});//不行
28
}

所以我们如果没有指明模板参数，则根据推导规则，类型有冲突且不能通过隐式类型转换解决问题。但是前面两个我们指明了模板参数，跳过了推导这一过程，则直接进入重载决议这一阶段就可以进行类型转换。

2.6 多模板参数的偏特化#

偏特化有多种形式。下面的几种都可以。但是注意约束：

• 类模板偏特化的形参参数个数是可以和主模板不一样的，它既可以多于主模板，也可以少于主模板。但是偏特化的实参必须与主模板对应的参数相匹配。------出自16.4章
  • 非常重要！！在特化类模板的时候，可以改变特化版本的形参列表的参数数量。但是最终落实（传入/应用）到实参上面的时候，参数数量不可变。
  • 此外，显式书写的模板实参数量与主模板的模板参数数量甚至也可能不同。尤其会在拥有默认模板实参或拥有可变模板时发生
• 偏特化的参数列表不能具有默认实参；作为替代，主类模板的默认实参会被使用。
• 偏特化的非类型实参要么是一个非依赖型值，要么是一个普通的非类型模板参数。它们不能是更加复杂的表达式，诸如2*N（N是一个模板参数）。
• 偏特化的模板实参列表不应该与主模板的参数列表完全相同（忽略重命名）。
• 如果模板实参的某一个是包展开，那么它必须位于模板实参列表的最后。

1
template<typename T1, typename T2>
2
class MyClass {
3
    //主模板
4
};
5

6
template<typename T>
7
class MyClass<T,T> {
8
    //两个参数同一个类型。
9
    //注意这里不一定非得写T1 T1。类型具体叫什么没所谓
10
    //特化模板的形参列表的参数数量可以变。但是实参列表的参数数量不可变。主模板是两个形参，我们就要传入两个实参。
11
};
12

13
template<typename T>
14
class MyClass<T,int> {
15
    //第二个参数是int
16
};
17

18
template<typename T1, typename T2>
19
class MyClass<T1*,T2*> {
20
    //两个参数为指针。
21
};

• 我们之前提到过特化的时候塞进去的是实参argument。塞进去的实参必须和主模板的形参数量匹配。为什么这么重要？我们理解一下：

1
template<typename T1> //主模板只有一个形参
2
class test;
3
//----------VERSION 1---------------------
4
template<typename T1, typename... T2>
5
class test<T1, T2 ...>{ //实参数量不匹配
6

7
};
8

9
int main(){
10
    test<int,float, double> obj;
11
}
12

13
//-----------VERSION 2----------------------
14

15
template<typename T1>
16
class test;
17
template<typename T1, typename... T2> //形参可以不同但是实参必须匹配
18
class test<T1(T2 ...)>{//实参匹配
19

20
};
21

22
int main(){
23
    test<int(float, double)> obj; //实参和实参必须数量对应。
24
}

• 为啥version1不行，version2可以？

我们说了，特化的时候必须匹配主模板的模板形参数量。我们version 1塞进去了两个模板实参。这样发生了问题。

version2为啥可以？尽管我们特化的时候，针对这个特化的模板形参是两个。但是我们在实际传入实参的时候，T1 和 T2...被合成了一个函数类型T1(T2...)。这一整个打包起来会变成主模板眼中的T1。注意这是函数类型并非函数指针类型

• 所以说甚至可以对成员指针进行特化：

1
template<typename T>
2
class List {//主模板
3
};
4
template<typename T, typename C>
5
class Class<T* C::*> { //针对成员指针的特化。T* C::*在主模板眼里是它的整个T
6

7
};

• 为什么我们main函数中的实例化也要写成int(float, double)的形式？因为实参和实参必须相匹配。举个最简单的例子：

1
template<typename T1, typename T2>
2
class MyClass {
3
    //主模板
4
};
5

6
template<typename T>
7
class MyClass<T,T> {
8
};

这是我们提到的例子。我们实例化的时候应该怎么写？是不是应该写Myclass<int, int>这种形式的？不能写Myclass<int>对吧？

• 为啥我这么关心这个？因为这是packaged_task和function的模板实现方式

1
template< class >
2
class packaged_task; //主模板
3
template< class R, class ...ArgTypes >
4
class packaged_task<R(ArgTypes...)>; //特化。
5

6
template< class >
7
class function; //主模板
8
template< class R, class... Args >
9
class function<R(Args...)>;//特化。

2.7 类模板默认参数#

类模板自然可以有默认参数。比如很多STL的实现。下面是一个小例子

1
template<typename T1, typename T2 = int>
2
class obj{
3
     public:
4
     obj(T1 a, T2 b):val1(a), val2(b){};
5
     T1 val1;
6
     T2 val2;
7
};

2.8 类型别名 Aliases#

一般来说，我们有两种方式可以给类型定义别名。using 和 typedef

• typedef

  1
  template<typename T>
  2
  class myobj{
  3
      public:
  4
      myobj(T a):val(a){};
  5
      T val;
  6
  };
  7
  
  8
  typedef myobj<int> INTmyobj;
  9
  typedef myobj<double> DOUBLEmyobj;
  10
  
  11
  int main(){
  12
      INTmyobj im(2);
  13
      DOUBLEmyobj dm(2.345);
  14
      cout << im.val << endl;
  15
      cout << dm.val << endl;
  16
      return 0;
  17
  }
  

• using

1
using usingINTmyobj = myobj<int>;
2
using usingDOUBLEmyobj = myobj<double>;
3

4
usingINTmyobj im(2);
5
usingDOUBLEmyobj dm(2.345);

1
template<typename T>
2
typedef myobj<T> intobj;

1
template<typename T>
2
using intobj = myobj<T>;
3

4
intobj<int> myobj(2);

2.9 类模板的类型推导#

直到C++17，我们都必须显式指出所有类模板参数的类型。除非拥有默认值。

剩下的看书。

2.10 聚合类型的模板化#

可以定义聚合类的类模板。关于聚合类，参考聚合初始化。

2.11 类模板成员函数或变量的类外实现[自己添加]#

基本类代码

1
template<typename T>
2
class test{
3
    public:
4
    T val;
5
    static T s_val;
6
    void func(T val);
7
    T func1();
8
    void func2();
9

10
};

1
template<typename T>
2
T test<T>::s_val = 102;
3

4

5
int main(){
6
    test<int> obj;
7
    test<double> obj2;
8
    cout << obj.s_val<< endl; //输出102
9
    cout << obj2.s_val << endl; //输出102
10
    obj2.s_val = 12345;
11
    cout << obj.s_val<< endl; //输出102
12
    cout << obj2.s_val << endl; //输出12345
13
    return 0;
14
}

1
template<typename T>
2
T test<T>::s_val = 102;
3

4

5
template<typename T>
6
void test<T>::func(T val){
7
    cout <<"func" << endl;
8
}
9

10
template<typename T>
11
T test<T>::func1(){
12
    cout <<"func1" << endl;
13
}
14

15
template<typename T>
16
void test<T>::func2(){
17
    cout <<"func2" << endl;
18
}

3.1 类模板的非类型模板参数 - 3.2 函数模板的非类型模板参数#

1
template<typename T>
2
void func(T obj){
3
    //...
4
}
5

6
int main(){
7
    func<int>(5);
8
    return 0;
9
}

• 我们都知道模板参数一般都是类型。比如这里，T就是int。是类型。当我们希望传入一个不是类型的参数的时候，比如如果我们有时候需要一些特殊情况， 例如想要传点奇怪东西的时候就可以使用非类型模板参数。

1
template<typename T, int MAXSIZE> //注意语法。这里非类型模板参数不再是typename了
2
void func1(T obj){
3
    vector<T>a;
4
    a.reserve(MAXSIZE);
5
    cout << a.capacity() << endl;
6
    a.push_back(obj);
7
    cout << a[0] << endl;       //干啥了不解释了 忽略即可
8
}

• 这里的int MAXSIZE就是非类型模板参数。因为他不是类型，而是变量。

使用非类型模板参数是有限制的。通常它们只能是：

1. 整型常量或字面值（包含枚举，或可隐式转换的比如bool）（string double都不可以。前者是类对象，后者是浮点数）
2. 指针类型
3. 成员指针类型
4. 对象/函数的左值引用
5. std::nullptr_t
6. 包含auto或decltype(auto)的类型 [C++17后]
   • 这个比较常用在把无捕获的lambda当做非类型模板参数进行传入。[C++20后]
     • 参考cppreference的非类型模板形参

当传递对象的指针或者引用作为模板参数时，对象不能是字符串常量，临时变量或者数据成员以及其他子对象。由于C++17之前，C++每次版本更新都会放宽以上限制，因此还有一些针对不同版本的限制：

• C++11中，对象必须要有外部链接
• C++14中，对象必须是外部链接或者内部链接

所以：传入的s必须是常量。

1
const int s = 8;  //必须是const
2
func1<int, s>(5);
3
func2<int, 4>(5); //或者直接传入字面值。

1
template<typename T, bool option>
2
class myclass; //主模板不实现
3

4
template<typename T>
5
class myclass<T, true>{ //偏特化1，注意语法。T在这里依旧要写上。
6
    public:
7
    void func(){
8
        cout <<"true one" << endl;
9
    }
10
};
11

12

13
template<typename T>
14
class myclass<T, false>{ //偏特化2，注意语法。T在这里依旧要写上。
15
    public:
16
    void func(){
17
        cout <<"false one" << endl;
18
    }
19
};
20

21
int main(){
22
    const bool myoption = true;
23
    myclass<int, false> obj; //直接使用字面值
24
    obj.func();
25
    myclass<int, myoption> obj1; //或必须用const常量变量。
26
    obj1.func();
27
    return 0;
28
}

1
template<typename T, int TS = 5> //注意语法。这里非类型模板参数不再是typename了
2
class myobj{
3
    public:
4
    myobj(T a):val(a){my_vec.reserve(TS);};
5
    T val;
6
    vector<T> my_vec;
7
};
8

9
template <typename T, int TS = 10> //注意语法。这里非类型模板参数不再是typename了
10
void func(T a){
11
    vector<T> my_vec(TS);
12
    cout <<"called" << endl;
13
    cout << my_vec.capacity() << endl;
14
}
15
int main(){
16
    myobj<int,8> instance(10);
17
    cout << instance.my_vec.capacity() << endl;
18
    //输出8
19
    func<int, 9>(2);
20
    //输出 called 9
21

22
    return 0;
23
}

3.3 避免无效表达式#

非类型模板参数可以是任何编译器表达式。比如：

1
//函数模板
2
template <int size, bool judge> //注意表达式不写在这。
3
void func(){
4
    cout << size << endl;
5
    if(judge == true){
6
        cout << "true" << endl;
7
    }
8
    else{
9
        cout << "false" << endl;
10
    }
11
}
12

13
//类模板
14
template <int size, bool judge>
15
class myobj{
16
    public:
17
    myobj(){
18
        my_vec.reserve(size);
19
        testfunc();
20
    };
21
    void testfunc(){
22
        cout << my_vec.capacity() << endl;
23
        if(judge == true){
24
            cout << "true" << endl;
25
        }
26
        else{
27
            cout << "false" << endl;
28
        }
29
    }
30
    vector<int> my_vec;
31
};
32
int main(){
33
    func<10, sizeof(int) == 4>(); //注意表达式写在这。写在实例化位置而非模板参数位置。
34
    //输出true
35
    func<10, (sizeof(int) > 4 )>(); //注意这里表达式要额外一组括号。
36
    //输出false
37
    myobj<10, sizeof(int) == 4> instance;
38
    //输出10 true
39
    myobj<10, (sizeof(int) > 4 )> instance1;
40
    //输出10 false
41
    return 0;
42
}

• 不过如果在表达式中使用了 operator >，就必须将相应表达式放在括号里面，否则>会被作为模板参数列表末尾的>，从而截断了参数列表

3.4 使用auto做为非模板类型参数 （C++17）#

暂略。看书。