使用模板参数重载分辨率

时间:2016-09-06 18:30:34

标签: c++ templates overload-resolution

我无法理解为什么以下会导致模糊的呼叫:

#include <iostream>

// generic version f(X, Y)
template <class X, class Y>
void f(X x, Y y) {
    std::cout << "generic" << std::endl;
}

// overload version
template <class X>
void f(X x, typename X::type y) {
    std::cout << "overload" << std::endl;
}

struct MyClass {
    using type = int;
};

int main() {
    f(MyClass(), int()); // Call to f is ambiguous
}

我希望选择比第二个参数更专业的重载版本作为最佳候选版本。我知道如果我将重载版本更改为

template <class X>
void f(X x, int y) {
    std::cout << "overload" << std::endl;
}

然后调用就好了,这意味着它与X :: type是模板相关名称的事实有关,但仍然无法解决它失败的原因。非常感谢任何帮助。

1 个答案:

答案 0 :(得分:8)

首先,我们挑选可行的候选人。那些是:

void f(MyClass, int);                    // with X=MyClass, Y=int
void f(MyClass, typename MyClass::type); // with X=MyClass

这些候选者都采用相同的参数,因此具有相同的转换序列。所以没有一个基于这些的破坏者适用,所以我们回到[over.match.best]中最后一个可能的决胜局:

  

鉴于这些定义,可行函数F1被定义为比另一个可行函数更好的函数   F2如果对于所有参数i,ICSi(F1)不是比ICSi(F2)更差的转换序列,则F1和F2是功能模板特化,F1的功能模板更专业   根据14.5.6.2中描述的偏序规则,比F2的模板。

因此,我们尝试根据部分排序规则对两个函数模板进行排序,这些规则涉及为每个模板参数合成一个唯一类型,并尝试针对每个过载重复执行模板。但是来自[temp.deduct.partial]的关键附加相关规则:

  

从参数模板中提取的每种类型以及参数中的相应类型   模板用作P和A的类型。如果特定P不包含参与的模板参数   在模板参数推导中,P不用于确定排序。

那是什么意思呢。首先,让我们尝试从重载推断出通用版本。我们选择合成类型UniqueX(对于X)和UniqueX_type(对于typename X::type),看看我们是否可以调用泛型函数。这成功(使用X=UniqueXY=typename X::type)。

让我们试试逆。我们选择UniqueX(对于X)和UniqueY(对于Y)并尝试执行模板扣除。对于第一个P / A对,这很简单。但是对于第二个参数,X是一个非推导的上下文,您认为这意味着模板推导失败。 但是根据报价的粗体部分,我们只是为了订购而跳过这个P / A对。因此,由于第一个P / A对成功,我们认为整个演绎过程已经成功。

由于模板扣除在两个方向都成功,我们不能选择一个功能或另一个功能更专业。由于没有其他的破坏者,没有单一的最佳可行候选者,因此呼叫是模棱两可的。

当第二个重载更改为:

template <class X> void f(X, int);

流程中发生变化的部分是现在在一个方向上的演绎失败了。我们可以推导出X=UniqueX,但第二对的参数类型为int,参数类型为UniqueY,这将无效,因此此方向失败。反方向,我们可以推导出X=UniqueXY=int。这使得这种过载比泛型过载更加专业化,所以它最好是我最初提到的最后一个决胜局。

作为附录,请注意模板的部分排序很复杂。考虑:

template <class T> struct identity { using type = T; };

template <class T> void foo(T );                             // #1
template <class T> void foo(typename identity<T>::type );    // #2

template <class T> void bar(T, T);                           // #3
template <class T> void bar(T, typename identity<T>::type ); // #4

foo(0);      // calls #1, #2 isn't even viable
foo<int>(0); // calls #2
bar(0,0);    // calls #3! we fail to deduce 3 from 4, but we succeed
             // in deducing 4 from 3 because we ignore the second P/A pair!