SFINAE 确定类型是否具有潜在的重载方法

Question

我正在寻找一个 SFINAE 解决方案来在编译时检查一个类型是否有方法。我的目标是检查一个类型是否是有效的"duck type"，但我想使用static_assert 来提供信息性消息，而不是无用的编译错误。

我找到了 [this question]，它为我的问题提供了一个相当好的答案，但当类型为方法提供重载时它会失败：

template<typename...> // parameter pack here
using void_t = void;

template<typename T, typename = void>
struct has_xxx : std::false_type {};

template<typename T>
struct has_xxx<T, void_t<decltype(&T::xxx)>> :
  std::is_member_function_pointer<decltype(&T::xxx)>{};

这适用于以下示例，并区分方法和成员变量：

struct Foo { int xxx() {return 0;}; };
struct Foo2 {};
struct Foo3{ static double xxx;};
double Foo3::xxx = 42;

int main() {
   static_assert(has_xxx<Foo>::value, "");
   static_assert(!has_xxx<Foo2>::value, "");
   static_assert(!has_xxx<Foo3>::value, "");
}

Original live demo

如果出现重载，代码会失败：

struct Foo { int xxx() {return 0;}  void xxx(int){} };

int main() {
   static_assert(has_xxx<Foo>::value, "");
}

Failing live demo with overloaded method

如何改进此代码以处理重载？

Answer 1

如果您所做的只是检查 name xxx 是否存在于类型 T 中，那么我们可以采用以下方法适用于所有非 final/@987654324 @ 类型 T。我们可以创建一个从T 公开继承的新类型和一个具有成员xxx 的后备类型。当且仅当T 没有开始的成员时，我们才能明确地访问派生类型上的xxx。

template <class T>
class has_xxx_impl
{
private:
    struct Fallback {
        int xxx;
    };

    struct Derived : T, Fallback { };

    template <class U>
    static std::false_type test(decltype(&U::xxx)* );
    template <class U>
    static std::true_type test(...);
public:
    using type = decltype(test<Derived>(nullptr));
};

template <class T>
struct has_xxx : has_xxx_impl<T>::type
{ };

如果你想检查更具体的事情——比如T，你可以打电话给T{}.xxx()，我会做不同的事情。

Answer 2

正确的鸭子类型检查是“您的xxx 是否可以使用特定签名调用，并且它的返回值在特定上下文中使用”。重载的xxx 没有用处，因为它的使用方式很重要。

我们从can_apply开始

namespace details {
  template<template<class...>class Z, class, class...>
  struct can_apply:std::false_type{};
  template<template<class...>class Z, class...Ts>
  struct can_apply<Z, std::void_t<Z<Ts...>>, Ts...>:
    std::true_type{};
}

template<template<class...>class Z, class...Ts>
using can_apply=details::can_apply<Z, void, Ts...>;

告诉你给定的参数是否可以合法地传递给某个模板。

然后我们表达我们想要的鸭子类型：

template<class T>
using xxx_result = decltype( std::declval<T>().xxx() );

template<class T>
using can_xxx = can_apply< xxx_result, T >;

而can_xxx<T> 是真还是假取决于我们是否可以做t.xxx()。

如果我们想要类型限制，我们只需：

template<class T, class R>
using xxx_result_as_R = decltype( R(std::declval<T>().xxx()) );
template<class T, class R>
using can_xxx_as_R = can_apply< xxx_result_as_R, T, R >;

所以如果你想让xxx 返回一些东西int-able，我们得到：

template<class T>
using valid_xxx = can_xxx_as_R<T, int>;