类模板实参推导（CTAD）(C++17 起)

为了实例化一个类模板，需要知晓每个模板实参，但并非每个模板实参都必须指定。在下列语境中，编译器会从初始化式的类型推导缺失的模板实参：

任意指定变量及变量模板的初始化的声明，其声明的类型是类模板（可有 cv 限定）：

std::pair p(2, 4.5);// 推导出 std::pair<int, double> p(2, 4.5);std::tuple t(4, 3, 2.5);// 同 auto t = std::make_tuple(4, 3, 2.5);std::less l;// 同 std::less<void> l;

new 表达式：

template<class T>struct A { A(T, T);};   auto y = new A{1, 2};// 分配的类型是 A<int>

函数式转换表达式：

auto lck =std::lock_guard(mtx);// 推导出 std::lock_guard<std::mutex>std::copy_n(vi1, 3, std::back_insert_iterator(vi2));// 推导出 std::back_insert_iterator<T>，// 其中 T 是容器 vi2 的类型std::for_each(vi.begin(), vi.end(), Foo([&](int i){...}));// 推导出 Foo<T>，其中 T 是独有的 lambda 类型

常量模板形参的类型：

template<class T>struct X {constexpr X(T){}};   template<X x>struct Y {};   Y<0> y;// OK, Y<X<int>(0)>

(C++20 起)

如果 e_i 是数组且 arg_i 是花括号初始化式列表，那么 T_i 是到 e_i 的声明类型的右值引用。
如果 e_i 是数组且 arg_i 是字符串字面量，那么 T_i 是到具有 const 限定的 e_i 的声明类型的左值引用。
否则，T_i 是 e_i 的声明类型。
如果有包因为它并非尾部聚合体元素而被跳过，那么在它原本的聚合体元素的位置插入形为 P_i ... 的形参包。（这通常会导致推导失败。）
如果包是尾部的聚合体元素，那么将对应它的尾部形参序列替换成形为 T_i ... 的单个形参。

聚合推导候选是从假想构造函数 C(T₁, T₂, ..., T_n) 按上述方式得到的虚设函数模板。

在聚合推导候选的模板实参推导中，只有在尾部的形参包的元素数无法从其他情况下推导时，才会从尾部的函数实参数推导。

template<class T>struct A { T t;   struct{long a, b;} u;};   A a{1, 2, 3};// 聚合推导候选：// template<class T>// A<T> F(T, long, long);   template<class... Args>struct B :std::tuple<Args...>, Args... {};   B b{std::tuple<std::any, std::string>{}, std::any{}};// 聚合推导候选：// template<class... Args> // B<Args...> F(std::tuple<Args...>, Args...);   // 推导出 b 的类型是 B<std::any, std::string>

(C++20 起)

然后，针对某个假想类类型的虚设对象的初始化，进行模板实参推导和重载决议，对于组成重载集而言，该类的各构造函数的签名与各个指引（除了返回类型）相匹配，并且由进行类模板实参推导的语境提供它的初始化式。但如果它的初始化式列表由单个（可有 cv 限定的）U 类型的表达式组成，其中 U 是 C 的特化或派生自 C 的特化的类，那么跳过列表初始化的第一阶段（考虑初始化式列表构造函数）。

这些虚设构造函数是该假想类类型的公开成员。如果推导指引从显式的构造函数组成，那么它们也是显式的。如果重载决议失败，那么程序非良构。否则，选中的 F 的返回类型就成为推导出的类模板特化。

template<class T>struct UniquePtr { UniquePtr(T* t);};   UniquePtr dp{new auto(2.0)};   // 一个声明的构造函数：// C1：UniquePtr(T*);   // 隐式生成的推导指引集：   // F1：template<class T>// UniquePtr<T> F(T *p);   // F2：template<class T>// UniquePtr<T> F(UniquePtr<T>); // 复制推导候选   // 要初始化的假想类：// struct X// {// template<class T>// X(T *p); // 从 F1// // template<class T>// X(UniquePtr<T>); // 从 F2// };   // X 对象的以“new double(2.0)”为初始化式的直接初始化// 会选择与 T = double 对应的指引 F1 的构造函数// 对于 T=double 的 F1，返回类型是 UniquePtr<double>   // 结果：// UniquePtr<double> dp{new auto(2.0)}

或者，对于更加复杂的例子（注意：“S::N”无法编译：作用域解析限定符不是可推导物）：

template<class T>struct S {template<class U>struct N { N(T); N(T, U);   template<class V> N(V, U);};};   S<int>::N x{2.0, 1};   // 隐式生成的推导指引是（注意已知 T 是 int）   // F1：template<class U>// S<int>::N<U> F(int);   // F2：template<class U>// S<int>::N<U> F(int, U);   // F3：template<class U, class V>// S<int>::N<U> F(V, U);   // F4：template<class U>// S<int>::N<U> F(S<int>::N<U>);（复制推导候选）   // 以“{2.0, 1}”为初始化式的直接列表初始化的重载决议// 选择 U=int 与 V=double 的 F3。// 返回类型是 S<int>::N<int>   // 结果：// S<int>::N<int> x{2.0, 1};

[编辑]用户定义的推导指引

用户定义的推导指引的语法是带尾随返回类型的函数声明的语法，但它以类模板名作为函数名：


explicit说明符 (可选)模板名`(`形参列表`)->`简单模板标识requires子句 (可选)`;`	(1)

`template <`模板形参列表 `>`requires子句 (可选) explicit说明符 (可选)模板名`(`形参列表`)->`简单模板标识requires子句 (可选)`;`	(2)

模板形参列表	-	非空的模板形参的逗号分隔列表
explicit说明符	-	explicit 说明符
模板名	-	要推导实参的类模板的名字
形参列表	-	（可以为空的）形参列表
简单模板标识	-	简单模板标识
requires子句	-	(C++20 起)requires 子句

用户定义的推导指引中的形参不能具有占位类型：不能使用简写函数模板形式。

(C++20 起)

用户定义的推导指引必须指名一个类模板，且必须在类模板的同一语义作用域（可以是命名空间或外围类）中引入，而且对于成员类模板必须拥有同样的访问，但推导指引不会成为该作用域的成员。

推导指引不是函数且没有函数体。推导指引不会被名字查找所找到，并且除了在推导类模板实参时与其他推导指引之间的重载决议之外不会参与重载决议。不能在同一翻译单元中为同一类模板再次声明推导指引。

// 模板的声明template<class T>struct container { container(T t){}   template<class Iter> container(Iter beg, Iter end);};   // 额外的推导指引template<class Iter> container(Iter b, Iter e)-> container<typenamestd::iterator_traits<Iter>::value_type>;   // 使用 container c(7);// OK：用隐式生成的指引推导出 T=intstd::vector<double> v ={/* ... */};auto d = container(v.begin(), v.end());// OK：推导出 T=double container e{5, 6};// 错误：std::iterator_traits<int>::value_type 不存在

为重载决议而虚设的构造函数（如上文所述）在对应到从显式构造函数组成的隐式生成的推导指引，或对应到声明为 explicit 的用户定义推导指引时是 explicit 的。像往常一样，在复制初始化语境中忽略这些构造函数：

template<class T>struct A {explicit A(const T&, ...)noexcept;// #1 A(T&&, ...);// #2};   int i; A a1 ={i, i};// 错误：不能从 #2 的右值引用推导// 且 #1 是 explicit 的，所以复制初始化中不予考虑。 A a2{i, i};// OK，#1 推导出 A<int> 并且初始化 A a3{0, i};// OK，#2 推导出 A<int> 并且初始化 A a4 ={0, i};// OK，#2 推导出 A<int> 并且初始化   template<class T> A(const T&, const T&)-> A<T&>;// #3   template<class T>explicit A(T&&, T&&)-> A<T>;// #4   A a5 ={0, 1};// 错误：#3 推导出 A<int&> 且 #1 和 #2 会生成形参相同的构造函数。 A a6{0, 1};// OK，#4 推导出 A<int> 并以 #2 初始化 A a7 ={0, i};// 错误：#3 推导出 A<int&> A a8{0, i};// 错误：#3 推导出 A<int&>   // 注：请查看 https://github.com/cplusplus/CWG/issues/647，// 称示例 a7 与 a8 不正确，可替换为//A a7 = {0, i}; // 错误：#2 与 #3 都匹配，重载解析失败//A a8{i,i}; // 错误：#3 推导出 A<int&>，#1 和 #2 声明同一个构造函数

在构造函数或构造函数模板的形参列表中使用成员 typedef 或别名模板的行为自身不会使隐式生成的指引的对应形参变为不推导语境。

template<class T>struct B {template<class U>using TA = T;   template<class U> B(U, TA<U>);// #1};   // 从 #1 产生的隐式推导指引等价于// template<class T, class U>// B(U, T) -> B<T>;// 而不是// template<class T, class U>// B(U, typename B<T>::template TA<U>) -> B<T>;// 后者无法被推导   B b{(int*)0, (char*)0};// OK，推导出 B<char*>

别名模版的推导

当函数式转换或变量定义用到了以不带实参列表的别名模板 A 为类型说明符的名字，其中 A 定义为 B<ArgList> 的别名，而 B 的作用域为非依赖且 B 是类模板或定义相似的别名模板时，推导将以与类模板相同的方式进行，但改为从 B 的指引生成指引，方式如下：

对于 B 的每个指引 f，用模板实参推导从 B<ArgList> 推导 f 的返回类型的模板实参，但推导即使在有实参没有被推导出的时候也不会失败。如果推导因为其他原因失败，那么以空集作为推导出的模板实参集。
替换上述推导结果到 f 中，如果替换失败，那么就不会生成指引；否则，令 g 代表替换结果，构成指引 f'，使得：

f' 的形参类型和返回类型与 g 的相同
如果 f 是模板，那么 f' 是模板形参列表包含了以下内容的函数模板；否则（f 不是模板）f' 是函数：

在上述推导出现的 A 的所有模板形参（包含其默认模板实参）
在前一条找到的默认模板实参（如果存在）中出现的 A 的所有模板形参（包含其默认模板实参）
如果再次找到默认模板实参，那么递归地包含在这些默认模板实参中出现的 A 的所有模板形参（包含其默认模板实参）
后随 f 未被推导的模板形参（包含其默认模板实参）

f' 的关联约束是 g 的关联约束和当且仅当 A 的实参可以从结果类型推导这一约束的合取。

template<class T>class unique_ptr {/* ... */};   template<class T>class unique_ptr<T[]>{/* ... */};   template<class T> unique_ptr(T*)-> unique_ptr<T>;// #1   template<class T> unique_ptr(T*)-> unique_ptr<T[]>;// #2   template<class T> concept NonArray =!std::is_array_v<T>;   template<NonArray A>using unique_ptr_nonarray = unique_ptr<A>;   template<class A>using unique_ptr_array = unique_ptr<A[]>;   // 对 unique_ptr_nonarray 生成的推导指引：   // 从 #1（unique_ptr<T> 从 unique_ptr<A> 的推导产生 T = A）：// template<class A>// requires(argument_of_unique_ptr_nonarray_is_deducible_from<unique_ptr<A>>)// auto F(A*) -> unique_ptr<A>;   // 从 #2（unique_ptr<T[]> 从 unique_ptr<A> 的推导不产生结果）：// template<class T>// requires(argument_of_unique_ptr_nonarray_is_deducible_from<unique_ptr<T[]>>)// auto F(T*) -> unique_ptr<T[]>;   // 其中 argument_of_unique_ptr_nonarray_is_deducible_from 能定义为   // template<class>// class AA;   // template<class A>// class AA<unique_ptr_nonarray<A>> {};   // template<class T>// concept argument_of_unique_ptr_nonarray_is_deducible_from =// requires { sizeof(AA<T>); };   // 对 unique_ptr_array 生成的推导指引：   // 从 #1（unique_ptr<T>从 unique_ptr<A[]> 的推导生成 T = A[]）：// template<class A>// requires(argument_of_unique_ptr_array_is_deducible_from<unique_ptr<A[]>>)// auto F(A(*)[]) -> unique_ptr<A[]>;   // 从 #2（unique_ptr<T[]> 从 unique_ptr<A[]> 的推导生成 T = A）：// template<class A>// requires(argument_of_unique_ptr_array_is_deducible_from<unique_ptr<A[]>>)// auto F(A*) -> unique_ptr<A[]>;   // 其中 argument_of_unique_ptr_array_is_deducible_from 能定义为   // template<class>// class BB;   // template<class A>// class BB<unique_ptr_array<A>> {};   // template<class T>// concept argument_of_unique_ptr_array_is_deducible_from =// requires { sizeof(BB<T>); };   // 用法： unique_ptr_nonarray p(new int);// 推导出 unique_ptr<int>// 从 #1 生成的推导指引返回 unique_ptr<int>// 从 #2 生成的推导指引返回 unique_ptr<int[]>，它被忽略，因为// argument_of_unique_ptr_nonarray_is_deducible_from<unique_ptr<int[]>> 得不到满足   unique_ptr_array q(new int[42]);// 推导出 unique_ptr<int[]>// 从 #1 生成的推导指引失败（不能从 new int[42] 推导出 A(*)[] 中的 A）// 从 #2 生成的推导指引返回 unique_ptr<int[]>

(C++20 起)

[编辑]注解

只有在不存在模板实参列表时才会进行类模板实参推导。如果指定了模板实参列表，那么就不会发生推导。

std::tuple t1(1, 2, 3);// OK：推导std::tuple<int, int, int> t2(1, 2, 3);// OK：提供了所有实参   std::tuple<> t3(1, 2, 3);// 错误：tuple<> 中没有匹配的构造函数。不进行推导。std::tuple<int> t4(1, 2, 3);// 错误

聚合体的类模板实参推导通常需要用户定义的推导指引：

template<class A, class B>struct Agg { A a; B b;};// 隐式生成的指引由默认、复制及移动构造函数组成   template<class A, class B> Agg(A a, B b)-> Agg<A, B>;// ^ 此推导指引在 C++20 中能隐式生成   Agg agg{1, 2.0};// 从用户定义指引推导出 Agg<int, double>   template<class... T> array(T&&... t)-> array<std::common_type_t<T...>, sizeof...(T)>;auto a = array{1, 2, 5u};// 从用户定义指引推导出 array<unsigned, 3>

(C++20 前)

用户定义指引不必是模板：

template<class T>struct S { S(T);}; S(charconst*)-> S<std::string>; S s{"hello"};// 推导出 S<std::string>

在类模板的作用域中，没有形参列表的模板名是注入类名，并可以用作类型。这种情况下不发生类模板推导，但必须显式提供它的模板形参：

template<class T>struct X { X(T){}   template<class Iter> X(Iter b, Iter e){}   template<class Iter>auto foo(Iter b, Iter e){return X(b, e);// 不推导：X 是当前的 X<T>}   template<class Iter>auto bar(Iter b, Iter e){return X<typename Iter::value_type>(b, e); 必须指定所需的模板实参 }   auto baz(){return::X(0);// 不是注入类名；推导为 X<int>}};

在重载决议中，偏序的优先级高于是否从用户定义推导指引生成函数模板：如果从构造函数生成的函数模板比从用户定义的推导指引生成者更特化，那么会选择从构造函数生成的。因为复制推导候选常常比包装构造函数更特殊，所以此规则表明复制通常优于包装。

template<class T>struct A { A(T, int*);// #1 A(A<T>&, int*);// #2   enum{ value };};   template<class T, int N = T::value> A(T&&, int*)-> A<T>;// #3   A a{1, 0};// 使用 #1 推导出 A<int> 并以 #1 初始化 A b{a, 0};// 使用 #2（比 #3 更特殊）推导出 A<int> 并以 #2 初始化

当之前的决胜规则（包括偏序）无法分辨两个候选函数模板时，应用下列规则：

由用户定义指引生成的函数模板比从构造函数或构造函数模板隐式生成的函数模板更受偏好。
复制推导候选比所有其他从构造函数或构造函数模板隐式生成的函数模板更受偏好。
从非模板构造函数隐式生成的函数模板比从构造函数模板隐式生成的函数模板更受偏好。

template<class T>struct A {using value_type = T;   A(value_type);// #1 A(const A&);// #2 A(T, T, int);// #3   template<class U> A(int, T, U);// #4};// #5，复制推导候选 A(A);   A x(1, 2, 3);// 使用 #3，从非模板构造函数生成   template<class T> A(T)-> A<T>;// #6，比 #5 更不特殊   A a(42);// 使用 #6 推导出 A<int> 并以 #1 初始化 A b = a;// 使用 #5 推导出 A<int> 并以 #2 初始化   template<class T> A(A<T>)-> A<A<T>>;// #7，与 #5 一样特殊   A b2 = a;// 使用 #7 推导出 A<A<int>> 并以 #1 初始化

如果模板形参是类模板形参，那么到该形参的无 cv 限定的右值引用不是转发引用：

template<class T>struct A {template<class U> A(T&&, U&&, int*);// #1：T&& 不是转发引用// U&& 是转发引用   A(T&&, int*);// #2：T&& 不是转发引用};   template<class T> A(T&&, int*)-> A<T>;// #3：T&& 是转发引用   int i, *ip; A a{i, 0, ip};// 错误，不能从 #1 推导 A a0{0, 0, ip};// 使用 #1 推导出 A<int> 并以 #1 初始化 A a2{i, ip};// 使用 #3 推导出 A<int&> 并以 #2 初始化

当从类模板的某个特化类型的单个实参进行的初始化有问题时，通常与默认的包装相比，更偏好复制推导：

std::tuple t1{1};//std::tuple<int>std::tuple t2{t1};//std::tuple<int>，不是 std::tuple<std::tuple<int>>   std::vector v1{1, 2};// std::vector<int>std::vector v2{v1};// std::vector<int>，不是 std::vector<std::vector<int>>（P0702R1）std::vector v3{v1, v2};// std::vector<std::vector<int>>

除了复制 VS. 包装的特殊情形外，列表初始化中保持对初始化器列表构造函数的强偏好。

std::vector v1{1, 2};// std::vector<int>   std::vector v2(v1.begin(), v1.end());// std::vector<int>std::vector v3{v1.begin(), v1.end()};// std::vector<std::vector<int>::iterator>

在引入类模板实参推导前，避免显式指定实参的常用手段是使用函数模板：

std::tuple p1{1, 1.0};// std::tuple<int, double>，使用推导auto p2 =std::make_tuple(1, 1.0);// std::tuple<int, double>，C++17 前

功能特性测试宏	值	标准	功能特性
`__cpp_deduction_guides`	`201703L`	(C++17)	类模板的模板实参推导
`__cpp_deduction_guides`	`201907L`	(C++20)	聚合体和别名的 CTAD

[编辑]缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告	应用于	出版时的行为	正确行为
CWG 2376	C++17	即使在声明的变量的类型和要推导实参的类模板不同时也会进行类模板实参推导	此时不进行类模板实参推导
CWG 2628	C++20	隐式推导指引不会传递约束	会传递约束
CWG 2697	C++20	不明确用户定义的推导指引中是否可以使用简写函数模板形式	已禁止
CWG 2707	C++20	推导指引不能包含尾随的 requires 子句	可以包含
CWG 2714	C++17	隐式推导指引不会考虑构造函数的默认实参	会考虑
CWG 2913	C++20	CWG 问题 2707 的解决方案导致推导指引语法与函数声明语法不一致	调整语法
P0702R1	C++17	初始化器列表构造函数能架空复制推导候选，导致产生包装	复制时跳过初始化器列表阶段

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏(C++20)
语言支持库
概念库(C++20)
诊断库
内存管理库
元编程库(C++11)
通用工具库
容器库
迭代器库
范围库(C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库(C++17)
并发支持库(C++11)
执行控制库(C++26)
技术规范
符号索引
外部库

模板形参
模板实参
类模板
函数模板
类成员模板
变量模板(C++14)
模板实参推导
类模板实参推导(C++17)
显式（全）特化
部分特化
待决名
包(C++11)
sizeof...(C++11)
折叠表达式(C++17)
形参包索引(C++26)
SFINAE
约束与概念(C++20)
requires 表达式(C++20)

cppreference.com

名字空间

变换

查看

操作

类模板实参推导（CTAD）(C++17 起)

目录

[编辑]类模板的推导

[编辑]隐式生成的推导指引

[编辑]用户定义的推导指引

别名模版的推导

[编辑]注解

[编辑]缺陷报告

导航

工具箱