Question

请考虑以下代码：

template <class...>
using void_t = void;

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

template <class T>
void bar(T, void_t<decltype(std::declval<T>().foo())>* = 0) {}

struct A { void foo(); } a;
bar(a); // gives a compiler error on ambiguous call

所以问题是，为什么这些过载模糊不清？为什么编译器不会认为第二个重载比第二个重载更严格，更专业？

Answer 1

您正在尝试使用SFINAE在特定情况下强制选择特定候选者（此处，在T左值内部不存在任何参数的可调用实体void_t的存在。这里到底发生了什么？

struct A的模板已为namespace details { // if Z<Ts...> is invalid, false_type: template <template<class...> class Z, class always_void, class... Ts> struct can_apply : std::false_type {}; // if Z<Ts...> is valid, true_type: template <template<class...> class Z, class... Ts> struct can_apply<Z, std::void_t<Z<Ts...>>, Ts...> : std::true_type {}; } // alias to inject the void type where we need it for SFINAE: template <template<class...> class Z, class... Ts> using can_apply = details::can_apply<Z, void, Ts...>; template <typename T> using has_foo_t = decltype(std::declval<T>().foo()); template <typename T> using has_foo = can_apply<has_foo_t, T>;定义良好，因此在通话时您有两个有效的重载决策候选者。如果您想使用SFINAE，您必须确保对于任何给定的呼叫，只有一个过载可用。为此，您应该首先将测试嵌入到类型特征中。为此，您可以在Yakk's can_apply facility上举例说明我无耻地复制到这里，因为它非常符合您的需求：

// The enable_if with the negation is needed to invalidate
// this implementation when T indeed has foo().
// This is what you were missing in your original idea.
template <typename T>
std::enable_if_t<!has_foo<T>::value> bar(T) {
    std::cout << "T has no foo(void)" << std::endl;
}

template <typename T>
std::enable_if_t<has_foo<T>::value> bar(T) {
    std::cout << "T has a foo(void)" << std::endl;
}

现在我们只需要在模板定义中使用上面定义的特征：

df

您可以在Coliru上看到正在运行的示例。

Answer 2

执行此操作的常用方法之一是创建同等专用模板的分离。

#include <utility>
#include <iostream>

template<class T>
struct has_foo_impl
{
  template<class U> static auto test(U* p) -> decltype(p->foo(), void(), std::true_type()); 
  static auto test(...) -> decltype(std::false_type()); 

  using type = decltype(test((T*)nullptr));
};

template<class T> using has_foo = typename has_foo_impl<T>::type;

template <class...>
using void_t = void;

template <class T, std::enable_if_t<not has_foo<T>::value>* = nullptr>
void bar(T){
  std::cout << "not me\n";
}

template <class T, std::enable_if_t<has_foo<T>::value>* = nullptr>
void bar(T) {
  std::cout << "me\n";
}

struct A { void foo(); } a;

int main()
{
    bar(a); // "me"
}

Answer 3

这些功能都不是更专业。

无论如何，你可以通过使用两个重载函数来强制选择：

#include<utility>

template <class T>
void bar(char, T){}

template <class T>
auto bar(int, T) -> decltype(std::declval<T>().foo(), void()) {}

struct A { void foo(); } a;

int main() {
    bar(0, a);
}

0是int，首先尝试bar(int, T)。由于sfinae，如果T没有foo成员函数，则可以将其丢弃。无论如何，0可以投放到char，因此在这种情况下会选择bar(char, T)。
如果两个函数都是可行的解决方案，则会调用bar(int, T)，因为它不需要任何隐式转换，并且调用不再含糊不清。

Answer 4

这是用g ++编译的其他解决方案：

//g++  4.9.3

#include <iostream>

template <class T>
    void bar(T)
{std::cout << "not foo boo...\n";}

template <class T >
    void bar( decltype(std::declval<T>().foo(),T())) 
{std::cout << "foo\n";}

template <class T >
    void bar( decltype(std::declval<T>().boo(),T())) 
{std::cout << "boo\n";}

struct Foo { void foo(); } f;

struct Boo {void boo(); } b;

struct NotFooBoo { } n;
template <class T>
    auto func(T&& t)
{
    return bar<typename std::decay<T>::type>(std::forward<T>(t));
}
int main()
{
    func(f);
    func(b);
    func(n);
}

Answer 5

因为您正在使用重载函数的默认值，所以编译器不知道您要使用哪个函数。

void bar(T, void_t<decltype(std::declval<T>().foo())>* = 0)

没有

= 0

它工作正常。

/ EDIT

template <class...>
using void_t = void;

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

template <class T>
void bar(T, void_t<decltype(std::declval<T>().foo())>*)
{}

struct A
{
    void foo();
} a;

int main()
{
    bar(a);
    return 0;
}

有效。

The program '[7464] Project3.exe' has exited with code 0 (0x0).

具有默认参数的函数的C ++部分排序

5 个答案: