Class template argument deduction (CTAD) (since C++17)

• 常量模板参数的类型：

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

• F i 的 关联约束 是 C 的关联约束与 C i 的关联约束的合取。

• 此外，如果

• C 被定义且满足 聚合类型 的要求（假设任何依赖基类无虚函数或虚基类），
• C 没有用户定义的推导指引，且
• 变量从非空初始化器列表 arg1, arg2, ..., argn 初始化（可使用 指派初始化器 ），

则可能添加聚合推导候选。聚合推导候选的参数列表按如下方式从聚合元素类型生成：

• 令 e i 为将从 arg i 初始化的（可能递归的） 聚合元素 ，其中

• 对于具有以下特征的聚合元素，不考虑 大括号省略 ：

• 具有 依赖 的非数组类型，
• 具有 值依赖 边界的数组类型，或
• 具有依赖数组元素类型且 arg i 为 字符串字面量 的数组类型

• 若 C （或其本身为聚合的元素）具有作为 包展开 的基类：

• 若包展开是尾随聚合元素，则视为匹配初始化器列表的所有剩余元素；
• 否则，该包视为空。

• 若不存在这样的 e i ，则不添加聚合推导候选。
• 否则，按如下方式确定聚合推导候选的参数列表 T 1 , T 2 , ..., T n ：

• 若 e i 是数组且 arg i 是 花括号初始化列表 ，则 T i 为 e i 声明类型的右值引用。
• 若 e i 是数组且 arg i 是 字符串字面量 ，则 T i 为 e i 声明类型的 const 限定左值引用。
• 否则， T i 为 e i 的声明类型。
• 若因包是非尾随聚合元素而被跳过，则在原始聚合元素位置插入形式为 P j ... 的附加参数包。（这通常会导致推导失败。）
• 若包是尾随聚合元素，则对应参数的尾随序列被替换为形式为 T n ... 的单个参数。

聚合推导候选是通过上述方式从虚构构造函数 C(T 1 , T 2 , ..., T n ) 派生的虚构函数模板。

在聚合推导候选的模板实参推导期间，尾随参数包中的元素数量仅当无法通过其他方式推导时，才根据剩余函数实参的数量推导。

template<class T>
struct A
{
    T t;
    struct
    {
        long a, b;
    } u;
};
A a{1, 2, 3};
// aggregate deduction candidate:
//   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{}};
// aggregate deduction candidate:
//   template<class... Args>
//   B<Args...> F(std::tuple<Args...>, Args...);
// type of b is deduced as B<std::any, std::string>

用户定义推导指引的参数不能具有占位符类型：不允许使用 简写函数模板 语法。

别名模板的推导

当函数式转换或变量声明使用不带实参列表的别名模板 A 的名称作为类型说明符时，若 A 被定义为 B<ArgList> 的别名，且 B 的作用域是非依赖的，同时 B 是类模板或类似定义的别名模板，则推导将以与类模板相同的方式进行，不同之处在于推导指引将改为从 B 的指引生成，具体如下：

• 对于 B 的每个指引 f ，使用 模板实参推导 从 B<ArgList> 推导 f 返回类型的模板实参，但若部分实参未被推导，推导不会失败。若因其他原因推导失败，则继续处理并采用空的推导模板实参集合。
• 将上述推导结果代入 f ，若代入失败则不生成指引；否则，令 g 表示代入结果，将形成指引 f' ，使得

• f' 的参数类型和返回类型与 g 相同
• 若 f 是模板，则 f' 是函数模板，其模板形参列表由 A 的所有模板形参（包括其默认模板实参）组成，这些形参出现在上述推导中或（递归地）出现在其默认模板实参中，后跟 f 中未被推导的模板形参（包括其默认模板实参）；否则（ f 不是模板）， 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<A> 推导 unique_ptr<T> 得到 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<A> 推导 unique_ptr<T[]> 无结果）：
// 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<NonArray 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<A[]> 推导 unique_ptr<T> 得到 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<A[]> 推导 unique_ptr<T[]> 得到 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[]>