看完How to make these std::function parameters unambiguous?这个问题我完全糊涂了，到目前为止，我以为我理解什么是函数模板的部分排序，但是在阅读了那个问题之后，我写下了三个示例来检查编译器的行为，但收到的结果对我来说很难理解.

示例#1

template <class T>
void foo(T) {}

template <class T>
void foo(T&) {}

int main()
{
  int i;
  foo<int>(i); // error: call is ambiguous! 
}

问题:这两个函数都是可行的，这很明显，但不是那个占用 T& 的函数吗？比T更专业？相反，编译器会引发模棱两可的调用错误。

示例#2

#include <iostream>

template <class T>
struct X {};

template <>
struct X<int> 
{
  X() {}
  X(X<int&> const&) {} // X<int> is constructible from X<int&>
  // note: this is not a copy constructor!
};

template <>
struct X<int&> 
{
  X() {}
  X(X<int> const&) {} // X<int&> is constructible from X<int>
  // note: this is not a copy constructor!
};

template <class T>
void bar(X<T>) { std::cout << __PRETTY_FUNCTION__ << std::endl; }

template <class T>
void bar(X<T&>) { std::cout << __PRETTY_FUNCTION__ << std::endl; }

int main()
{
  bar<int>(X<int>());   // calls void bar(X<T>) [with T = int]

  bar<int>(X<int&>());  // calls void bar(X<T&>) [with T = int]
}

问题:如果 T&和 T在示例 #1 中是模棱两可的，那么为什么这里没有调用是模棱两可的？ X<int>可从 X<int&> 构建，以及 X<int&>可从 X<int> 构建感谢提供的构造函数。是不是因为编译器生成了X<int>::X(X<int> const&)复制构造函数是一个比X<int>::X(X<int&> const&) 更好的转换序列 ,(如果是这样，是什么让它变得更好，请注意参数是按值传递的)，所以特化的顺序根本不重要？

示例#3

#include <iostream>

// note: a new type used in constructors!
template <class U>
struct F {};

template <class T>
struct X
{
  X() {}

  template <class U>
  X(F<U> const&) {}  // X<T> is constructible from any F<U>
  // note: it takes F type, not X!
};

template <class T>
void qux(X<T>) { std::cout << __PRETTY_FUNCTION__ << std::endl; }

template <class T>
void qux(X<T&>) { std::cout << __PRETTY_FUNCTION__ << std::endl; }

int main()
{
  qux<int>(F<int>());  // calls void qux(X<T&>) [with T = int]

  qux<int>(F<int&>()); // calls void qux(X<T&>) [with T = int]
}

问题:现在这与“匹配 lambda [](int){} 与 std::function<void(int&)> 和 std::function<void(int)>” 类似。为什么在这两个调用中都选择了更专业的函数模板？是不是因为转换顺序相同，所以偏序开始重要了？

所有测试在 GCC 4.9.0 上完成 -std=c++11并且没有额外的标志。

最佳答案

重载解析试图找到这样的最佳函数:

(1) [over.match.best]/1:

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 (see 8.5, 13.3.1.5, and 13.3.1.6) and the standard conversion sequence from the return type of F1 to the destination type (i.e., the type of the entity being initialized) is a better conversion sequence than the standard conversion sequence from the return type of F2 to the destination type.
[ Example:

struct A {
  A();
  operator int();
  operator double();
} a;

int i = a;    // a.operator int() followed by no conversion is better 
              // than `a.operator double()`     
              // followed by a conversion to `int`
float x = a;  // ambiguous: both possibilities require conversions,
              // and neither is better than the other

— end example ] or, if not that,
— F1 is a non-template function 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.

案例一:

but isn't the one taking T& more specialized than T?

根据重载决议，没有转换更好(都是恒等转换，是精确匹配)，并且由于(1)中没有其他项目适用，因此进行了部分排序。 [temp.deduct.partial]/5 表示为了部分排序，引用被它们引用的类型替换:

Before the partial ordering is done, certain transformations are performed on the types used for partial ordering:
— If P is a reference type, P is replaced by the type referred to.
— If A is a reference type, A is replaced by the type referred to.

由于参数模板的参数完全相同，因此不难看出相互推导都是成功的——因此两个模板都不比另一个更专业。

案例二:

这里不需要部分排序。来自 X<int> 的用户定义转换至 X<int&>排名比转换 X<int> 差至 X<int> -- 后者由 [over.ics.user]/4 赋予完全匹配等级:

A conversion of an expression of class type to the same class type is given Exact Match rank, […]

因此它显然是比 X<int> 更好的转换至 X<int&> ，具有转化排名。反之亦然，对于 X<int&>至 X<int> .

案例三:

第三种情况与第一种类似。 X<int>和 X<int&>两者都有一个构造函数模板，可以采用 F 的任意特化。 . (1) 告诉我们，由于没有一个转换序列在任何方面都优于另一个(事实上，它们完全相同)，因此选择了更专业的模板。

template <class T> void bar(X<T>);  // #1

template <class T> void bar(X<T&>); // #2

// Call:
bar<int>( F<int>() );

回到[temp.deduct.partial]，执行类型推导。一个独特的类型，称之为Unique , 被合成为每个参数模板的模板参数。执行以下具有相应结果的过程 - 请注意，使用 F<int> 调用时，步骤完全相同与 F<int&> 一样(以及 F 的任何其他特化):

1. 模板#1 作为参数模板，模板#2 作为参数模板，X<Unique&>根据 X<T> 推导, 产生 T=Unique& .另一方面，
2. 模板#2 作为参数模板，模板#1 作为参数模板，X<Unique>根据 X<T&> 推导, 导致推演失败。

正如我们所见，模板 #2 更加特化。在步骤 1 中用作参数模板时，推导成功，而模板 #1 在步骤 2 中用作参数模板时，推导失败。因此，第二个更专业的函数模板的特化被称为。

关于c++ - 什么时候两个函数模板被认为是部分有序的，什么时候是不明确的？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26317798/