当参数是函数参数包时，在部分排序期间推导模板实参

N4527 14.8.2.4 [温度扣除部分]

3 用于确定排序的类型取决于完成部分排序的上下文：

(3.1) — 在函数调用的上下文中，使用的类型是函数调用具有参数的函数参数类型。

(3.2) — 在调用转换函数的上下文中，使用转换函数模板的返回类型。

(3.3) — 在其他上下文 (14.5.6.2) 中，使用函数模板的函数类型。

4 上面从参数模板中指定的每个类型以及来自参数的相应类型 模板被用作类型P and A.

8 If A由函数参数包转换而成P不是参数包，类型推导失败。 否则，使用结果类型P and A，然后按照 14.8.2.5 中的描述进行扣除。如果P是一个函数参数包，类型A参数模板的每个剩余参数类型是 与类型相比P函数参数包的声明符 ID。每次比较都推导出 由函数扩展的模板参数包中后续位置的模板实参 参数包。如果给定类型推导成功，则考虑参数模板中的类型 至少与参数模板中的类型一样专业。 [ 例子：

template<class... Args>           void f(Args... args);        // #1
template<class T1, class... Args> void f(T1 a1, Args... args); // #2
template<class T1, class T2>      void f(T1 a1, T2 a2);        // #3

f();        // calls #1
f(1, 2, 3); // calls #2
f(1, 2);    // calls #3; non-variadic template #3 is more
            // specialized than the variadic templates #1 and #2

Why f(1, 2, 3);调用#2？

我需要更多详细信息，包括：

1 这是哪个上下文？

2 变形后的形态有哪些？
例如#1 的变换是void (U) , void (U...)或者其他形式？（U表示独特的类型）

14.5.6.2 [临时函数顺序]/p3

为每个类型、非类型或模板模板参数（包括 模板参数包（其中的14.5.3））分别合成唯一的类型、值或类模板 并将其替换为模板函数类型中该参数的每次出现。

3 有哪些类型P and A用于推导？例如

template <class T> void f(T);
int a = 1;
f(a);//P = T, A = int

Why f(1, 2, 3);调用#2？

您的问题中有很多问题（请每个问题一个问题！），所以我会坚持这一个问题。首先，我们进行模板推导。 #3 失败，但 #1 和 #2 成功：

template<class... Args>
void f(Args... args);        // #1, with Args = {int, int, int}
template<class T1, class... Args> 
void f(T1 a1, Args... args); // #2, with T1 = int, Args = {int, int}

这两个函数都需要三个ints 按值，因此重载决策中的所有正常决胜局都无法解决歧义。所以我们到了最后一个：

Given these definitions, a viable function F1 is defined to be a better function than another viable function F2 if for all arguments i, ICS_i(F1) is not a worse conversion sequence than ICS_i(F2), and then
— [...]
— F1 and F2 are function template specializations, and the function template for F1 is more specialized than the template for F2 according to the partial ordering rules described in 14.5.6.2.

规则是：

Step 1：合成类型[temp.func.order]：

为每个类型、非类型或模板模板参数（包括 模板参数包（其中的14.5.3））分别合成唯一的类型、值或类模板 并将其替换为模板函数类型中该参数的每次出现。

所以我们有：

void f(Pack1... args);         // #1
void f(U2 a1, Pack2... args);  // #2

Step 2：按照[temp.deduct.partial]中的描述执行扣除。我们所处的上下文是函数调用，因此我们使用函数调用具有参数的类型。

首先，我们尝试从#1 推导出#2。也就是说，我们尝试匹配 (T1, Args...） 反对(Pack1...)。第一部分是P = T1, A = Pack1...。我们有：

如果 A 是从函数参数包转换而来并且 P 不是参数包，则类型推导失败。

所以从 #1 推导出 #2 失败，所以论证Args...至少不像T1, Args....

接下来，我们尝试从#2 中推导出#1。也就是说，我们尝试匹配(Args...)反对(U2, Pack2...)。这样就成功了，所以T1, Args...至少与Args....

由于#2 至少与#1 一样专业，而#1 至少不如#2 专业，因此我们可以说#2 更专业：

功能模板F至少与函数模板一样专业G如果，对于每对类型用于 确定排序、类型F至少与来自的类型一样专业G. F更专业 比G if F至少与G and G至少不像F.

更专业的模板是首选，所以我们称之为#2。