如何避免这句话在模板中是假的sfinae？

Question

所以我想编写一个自动的！=:

template<typename U, typename T>
bool operator!=(U&& u, T&& t) {
  return !( std::forward<U>(u) == std::forward<T>(t) );
}

但这是不礼貌的¹。所以我写

// T() == U() is valid?
template<typename T, typename U, typename=void>
struct can_equal:std::false_type {};

template<typename T, typename U>
struct can_equal<
   T,
   U,
   typename std::enable_if<
      std::is_convertible<
         decltype( std::declval<T>() == std::declval<U>() ),
         bool
      >::value
   >::type
>: std::true_type {};

template<typename U, typename T,
  typename=typename std::enable_if<can_equal<T,U>::value>::type
>
bool operator!=(U&& u, T&& t) {
  return !( std::forward<U>(u) == std::forward<T>(t) );
}

struct test {
};
bool operator==(const test&, const test&);
bool operator!=(const test&, const test&);

因此，我编写了这个特征类：

template<typename T, typename U,typename=void>
struct can_not_equal // ... basically the same as can_equal, omitted

它测试t！=u是否有效。

然后对！=进行如下扩充：

template<typename U, typename T,
  typename=typename std::enable_if<
    can_equal<T,U>::value
    && !can_not_equal<T,U>::value
  >::type
>
bool operator!=(U&& u, T&& t) {
  return !( std::forward<U>(u) == std::forward<T>(t) );
}

脚注¹:如果创建模板 bool操作符！=(U&&U,t&&t) ，SFINAE将认为每对类型之间都有一个有效的！=。然后，当您试图实际调用！=时，它被实例化，并且编译失败。在此基础上，您可以使用bool操作符！=(const foo&,const foo&)函数，因为您可以更好地匹配foo()！=foo()和fooa,b；a！=b；。我认为做这两件事都是不礼貌的。

Answer 1

您的方法的问题似乎是操作符！=的回退全局定义太吸引人了，您需要进行SFINAE检查才能排除它。但是，SFINAE检查依赖于函数本身用于重载解析的资格，从而导致在类型演绎期间（尝试）无限递归。

在我看来，任何基于SFINAE的类似尝试都将遇到同样的问题，因此在我看来，最明智的方法是首先降低运算符！=对重载解决的吸引力，然后让运算符！=的其他合理编写的重载（这将在稍后清楚地说明）优先。

给定您提供的类型特征CAN_EQUAL:

#include <type_traits>
#include <functional>

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

template<typename T, typename U>
struct can_equal<
   T,
   U,
   typename std::enable_if<
      std::is_convertible<
         decltype( std::declval<T>() == std::declval<U>() ),
         bool
      >::value
   >::type
>: std::true_type {};

我将这样定义回退运算符！=：

template<typename T, typename U>
bool is_not_equal(T&& t, U&& u)
{
    return !(std::forward<T>(t) == std::forward<U>(u));
}

template<
    typename T,
    typename... Ts,
    typename std::enable_if<can_equal<T, Ts...>::value>::type* = nullptr
    >
bool operator != (T const& t, Ts const&... args)
{
    return is_not_equal(t, args...);
}

据我所知，运算符！=的任何重载只要定义了两个函数参数（所以没有参数包）就更适合重载解析。因此，只有在没有更好的重载时，才会选择操作符！=的上述回退版本。而且，只有当can_equal<>类型特征返回true时，才会选择它。

我已经根据您准备的SSCE测试了这一点，其中定义了四个结构以及操作符==和操作符！=的重载：

struct test { };

bool operator==(const test&, const test&) { std::cout << "(==)"; return true; }
bool operator!=(const test&, const test&) { std::cout << "(!==)"; return true; }

struct test2 { };

struct test3 { };
bool operator == (const test3&, const test3&) 
{ std::cout << "(==)"; return true; }

struct test4 { };

template<typename T, 
         EnableIf< std::is_convertible< T, test4 const& >::value >... >
bool operator == ( T&&, T&& ) { std::cout << "(==)"; return true; }

template<typename T, 
         EnableIf< std::is_convertible< T, test4 const& >::value >... >
bool operator != ( T&&, T&& ) { std::cout << "(!=)"; return true; }

template<typename T, typename U>
bool is_not_equal(T&& t, U&& u)
{
    std::cout << "!"; // <== FOR TESTING PURPOSES
    return !(std::forward<T>(t) == std::forward<U>(u));
}

std::cout << (a != b) << "\n"; // #1
std::cout << (test3() != test3()) << "\n"; // #2
std::cout << (test4() != test4()) << "\n"; // #3

关于第一个测试，运算符！=是为类型test定义的，因此#1行应该打印：

(!==)1

关于第二个测试，运算符！=没有为test3定义，test3不能转换为test4，因此我们的全局运算符！=应该起作用，并否定运算符==的重载结果，该重载取两个常量test3&。因此，第#2行应打印：

!(==)0 // operator == returns true, and is_not_equal() negates it

最后，第三个测试涉及两个类型为test4的rvalue对象，为其定义了operator！=（因为参数可转换为test4 const&)。因此，第#3行应该打印：

(!=)1

这里有一个现场示例，表明所产生的输出是预期的。