1 类模板参数推导（CTAD）

1.1 曲线救国

​ CTAD 的全称是类模板参数推导（Class Template Argument Deduction），它允许在实例化类模板时，根据构造函数的参数类型自动推导模板参数，从而避免显式指定模板参数。CTAD 是在 C++ 17 引入的，在这之前，只有模板函数支持根据函数参数自动推导模板参数，类模板不支持这样的动作。代码中实例化类模板必须显式指定模板参数，十分不便，以致怨声载道。

​ C++ 11 引入了 auto，用作占位符衍生出了一种“工厂函数”惯用法，就是利用函数模板的推导规则，根据函数参数推导出模板参数，然后用推导出的模板参数实例化类对象。比如这个例子：

template<typename T, typename U>
class Foo {
public:Foo(T begin, U end) : m_begin(std::move(begin)), m_end(std::move(end)) {}
private:T m_begin;U m_end;
};template<typename T, typename U>
auto MakeFoo(T begin, U end) {return Foo<T, U>{begin, end};
}auto f2 = MakeFoo(42, 5.24);

1.2 隐式规则

​ C++ 17 的 CTAD 默认通过类模板的构造函数定义模板参数的推导规则，和函数模板一样，由构造函数的实参类型决定模板的参数类型。比如上一节的 Foo 类，不需要工厂函数，可以直接这样用：

Foo f1{42, 5.24};

但是编译器对类模板参数的推导是有条件的，那就是构造函数的形式参数列表必须能覆盖全部模板参数，并且这些形参都必须参与推导，不能有在非推导语境中的模板参数。简单来说，以下两个类模板就不支持 CTAD 隐式推导：

template<typename T, typename U>
struct Bar {Bar(const T& t) {}
};template<typename T, typename U>
struct Widget {Widget(const T& t, typename std::type_identity_t<U> u) {}
};Bar b1(42); //错误
Widget w(1, 2.3); //错误，不能实例化 Widget<int, double> 类型

Bar 的构造函数形参列表只覆盖了一个模板参数，另一个未知，不能通过构造函数同时推导出T 和 U 的类型。Widget 同样不支持 CTAD，它的构造函数形参覆盖了两个模板参数，但是 U 出现在典型的非推导语境中，它不参与推导，编译器不会根据实参 2.3 去推导 U 为 double，所以不能同时确定 T 和 U 的类型，也就无法实例化 Widget<int, double> 类型。

1.3 演化

​ CTAD 在 C++ 20 改善了一下对聚合类型的支持。对于聚合类型，可以在不提供显式构造函数的情况下，按照聚合类型的初始化顺序实现类型推导。我们假设下面例子中的 Foo 是个聚合类型，为什么假设呢？因为是不是聚合类型还要看它那三个成员的类型，我们这里给出的例子能确保 Foo 实例化后是个聚合类型。

template<typename T, typename U, typename V>
struct Foo {T t;U u;V v;
};Foo f{ 1, 2.3, "Hello" };

大括号中的参数，按照按照聚合类型的初始化顺序，以及传值类型模板形参的推导规则，依次与 t、u 和 v 匹配，推导出 T、U 和 V 的类型为 int、double 和 const char* ，并用 Foo<int, double, const char*> 类型初始化 f。

2 推断指示（Deduction Guides）

2.1 什么是推断指示

​ 尽管 CTAD 可以根据构造函数参数自动推导模板参数，但有些复杂情况下，隐式的规则可能无法满足需求。此时我们可以利用 C++ 17 的显示推断指示（推断指引），通过提供自定义的模板参数推导规则，让编译器知道如何确定类模板的模板参数，从而实现复杂类模板参数的自动推导。

​ 推断指示的语法大概是这个样子的：

//deduction-guide:
explicit(opt) template-name (parameter-declaration-clause) -> simple-template-id ;

explicit 关键字是可选的，用于说明是否是显式推断指示。这个语法的重点是 减号和大于号组成的箭头符号（->），箭头符号左边的 template-name 必须与箭头符号右边的 simple-template-id 具有相同的标识符。此外，如果一个 template-name 有多个推断指引，那么它们的 parameter-declaration-clause 不能相同。以 std::tuple 为例，看看它的推断指引的语法：

template<class... UTypes>
tuple(UTypes...) -> tuple<UTypes...>;

箭头符号的左边是 std::tuple 的构造函数（之一），其中 UTypes… 就是传递给构造函数的参数包（就是 parameter-declaration-clause）。箭头符号的右边是 std::tuple 的模板参数（simple-template-id），这个语法告诉编译器，可以根据构造函数的参数推断对应的类模板实例化使用的模板参数。

2.2 推断指示的典型用法

​ ContainerT 类有一个符合 CTAD 的构造函数，c1 就是通过这个构造函数提供的隐式规则，推导出 c1 的类型是 ContainerT。但是当我们希望传递一个大括号列表的时候，我们希望 T 是一个 vector 容器类型，此时构造函数提供的默认规则就无能为力了。c2 的定义会导致编译错误，因为模板形参推导不支持大括号列表（auto 的推导支持将大括号列表推导为具体的 std::initializer_list 类型，但这是个写死的规则，算不上推导）。

template <typename T>
class ContainerT {
public:ContainerT(T value) : val(value) {}T val;
};ContainerT c1(5); //ContainerT<int>
ContainerT c2({ 1, 5, 8 }); //错误

​ 为了达成目标，我们需要为 ContainerT 类模板提供一个显式推断指示，通过显式推断指示明确模板参数 T 是 vector 类型。这是我们提供的推断指示：

template <typename U>
ContainerT(std::initializer_list<U>) -> ContainerT<std::vector<U>>;

函数形参不支持自动推导成 std::initializer_list，我们干脆写死就是 std::initializer_list，它与大括号列表是可以匹配的，相当于只需推导 std::initializer_list 的模板参数 U。当确定了 U 之后，我们希望 ContainerT 的模板参数是 std::vector，这就是这条显式推断指示的语法解释。有了这条推断指示，c2 的定义就合法了，并且也得到了我们希望的 ContainerT<std::vector> 类型。

​ 再来看一个稍微复杂一点的例子：

template<typename T>
class Foo {
public:Foo(T value) {m_values.push_back(std::move(value));}template<class Iter>Foo(Iter begin, Iter end) {std::copy(begin, end, std::back_inserter(m_values));}
private:std::vector<T> m_values;
};Foo f1{ 5 }; // Foo<int> std::vector<int> vi{ 1, 3, 5, 7 };
Foo f2{ vi.begin(), vi.end() }; //错误

Foo 有两个构造函数，第一个构造函数配合 CTAD，使得 f1 的定义没有问题，但是 f2 的定义不被编译器支持，因为通过构造函数传递的两个迭代器，编译器无法推断出模板参数 T 的类型。当我们拿到一对迭代器的时候，我们可以通过类型萃取获得迭代器的值类型，可以将这个值类型指代类模板参数 T。

​ 按照这个思路得到推断指示：

template<class Iter>
Foo(Iter begin, Iter end)->Foo<typename std::iterator_traits<Iter>::value_type>;

有了这个显式推断指示，上面例子代码中 f2 的定义就合法了，并且得到的 f2 的类型也是我们希望的 Foo 类型。

2.3推断指示的非典型用法

​ 显示推断指引可以用在一些需要提供类模板特化版本的场合，比如下面这个例子中的 Foo 类模板，当面对指针类型的时候，比如字符串字面量，如果按照默认的构造函数提供的 CTAD，T 被推导为指针，成员 m_t 只保存了字符串的指针，在很多情况下，这都是比较危险的，一不小心就出现野指针访问。传统方法是针对指针类型提供特化版本，就如同这个例子一样。

template<class T>
struct Foo {Foo(T t) { m_t = t; }T m_t;
};//特化版本
template<>
struct Foo<const char*> {Foo(const char* t) { m_t = t; }std::string m_t;
};

​ 提供特化版本也没什么不妥，就是要敲很多键盘。但是如果用显式推断指示，只需一行代码就可以了：

//推断指引
Foo(const char*)->Foo<std::string>;

少敲几次键盘，还不需要提供函数体的代码，通过类型的指示，复用原来的构造函数，有什么利用不用推断指示？

3 总结

​ CTAD 拖了这么长时间实在气愤，好在显式推断指示让类模板参数的自动推导比函数模板的模式匹配强大 N 倍，也就没那么大的气了。显式推断指示在标准库中也是大量引用，比如你可以这样定义一个 array：

std::array arr{1, 2, 3, 4, 5};

因为它有一条这样的推断指示：

template <class... T>
array(T&&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;

参考资料

[1] Marc Gregoire, Professional C++ (Fifth Edition), John Wiley & Sons, Inc., 2021

[2] https://en.cppreference.com/w/cpp/language/class_template_argument_deduction

[3] Nicolai M. Josuttis, C++20 - The Complete Guide, http://leanpub.com/cpp20’

[4] Jacek Galowicz. C++17 STL Cookbook. Packtpub. 2017

[5] P0702：Language support for Constructor Template Argument Deduction

[6] CWG 2628：Implicit deduction guides should propagate constraints

关注作者的算法专栏
https://blog.csdn.net/orbit/category_10400723.html

关注作者的出版物《算法的乐趣（第二版）》
https://www.ituring.com.cn/book/3180