#include <iostream>

template <class U, class T>
void foo(U&, T&)
{
    std::cout << "first";
}

template <class T>
void foo(int&, const T&)
{
    std::cout << "second";
}

int main()
{
    int a;
    double g = 2.;
    foo(a, g); // prints "first"

    return 0;
}

调用第二个foo重载，编译器只需要执行一次模板类型推导，但对于第一次重载，它需要执行两次。你能解释一下为什么调用第一个重载吗？

最佳答案

重载解决方案分多个步骤完成。

首先，通过名称查找，我们选择可行的候选人列表。在这种情况下，即:

template <class U, class T>
void foo(U&, T&);            // with U = int, T = double

template <class T>
void foo(int&, const T&)     // with T = double

接下来，我们确定每个可行候选者的每个参数所需的转换顺序。这是[over.ics.rank]:

Standard conversion sequence S1 is a better conversion sequence than standard conversion sequence S2 if [...]

• S1 is a proper subsequence of S2 (comparing the conversion sequences in the canonical form defined by 13.3.3.1.1, excluding any Lvalue Transformation; the identity conversion sequence is considered to be a subsequence of any non-identity conversion sequence) or, if not that,
• the rank of S1 is better than the rank of S2, or S1 and S2 have the same rank and are distinguishable by the rules in the paragraph below, or, if not that,

对于第一次调用，转换顺序为(Identity, Identity)。对于第二次调用，转换顺序为(Identity，Identity)。所以我们在那里是平等的。这些要点都没有区分这两个电话。所以我们继续前进。

• S1 and S2 are reference bindings (8.5.3) and neither refers to an implicit object parameter of a non-static member function declared without a ref-qualifier, and S1 binds an rvalue reference to an rvalue and S2 binds an lvalue reference.

无关紧要。

• S1 and S2 are reference bindings (8.5.3) and S1 binds an lvalue reference to a function lvalue and S2 binds an rvalue reference to a function lvalue.

没有。

• S1 and S2 differ only in their qualification conversion and yield similar types T1 and T2 (4.4), respectively, and the cv-qualification signature of type T1 is a proper subset of the cv-qualification signature of type T2.

资格转换是指针的事情，不是。

• S1 and S2 are reference bindings (8.5.3), and the types to which the references refer are the same type except for top-level cv-qualifiers, and the type to which the reference initialized by S2 refers is more cv-qualified than the type to which the reference initialized by S1 refers.

在这种情况下，第一个重载将其第二个参数作为 double&，而第二个重载采用 const double&。前者的 cv 限定比后者少，所以我们在这里停止 - 更喜欢 foo(U&,T&)。

只有在确定哪种转换顺序更好的步骤之后，我们才能进入首选更专业模板的步骤。 [over.match.best] 中的完整规则排序为:

Given these definitions, a viable function F1 is defined to be a better function than another viable function F2 if for all arguments i, ICSi(F1) is not a worse conversion sequence than ICSi(F2), and then

• for some argument j, ICSj(F1) is a better conversion sequence than ICSj(F2), or, if not that,

这就是我们刚刚经历的。

• the context is an initialization by user-defined conversion [ ... ]
• the context is an initialization by conversion function for direct reference binding [ ... ]
• F1 is not a function template specialization and F2 is a function template specialization, or, if not that,
• 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.

这就是我们选择 foo(U&, T&) 的原因。但是，如果您删除 const，那么两个转换序列在所有步骤中都是相同的 - 因此，在这一点上，更专业的模板 (foo(int&, T&)) 会赢。

请注意，更专业的是确定最佳候选者的最后机制。这是决胜局的最后一场。

另请注意，模板扣除的数量是无关紧要的。 可能在作为模板的重载和不是模板的重载之间进行选择 - 但在具有 x 模板参数的重载和具有 y > x 模板参数的重载。

关于C++ 模板函数优先级，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31047860/