Ответ 1
Проблема с вашим подходом заключается в том, что глобальное определение operator != является слишком привлекательным, и для его устранения требуется проверка SFINAE. Однако проверка SFINAE зависит от возможности самой функции для разрешения перегрузки, что приводит к (попытке) бесконечной рекурсии при выводе типа.
Мне кажется, что любая подобная попытка, основанная на SFINAE, потерпела бы крах против одной и той же стены, поэтому самый разумный подход, на мой взгляд, должен сделать ваш operator != менее привлекательным для разрешения перегрузки в первую очередь, и пусть другие, разумно написанные (это будет ясно в какой-то момент) перегрузки operator != имеют преимущество.
Учитывая характерный признак 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 {};
Я бы определил резервный operator != следующим образом:
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...);
}
Насколько мне известно, любая перегрузка operator !=, которая будет определять ровно два параметра функции (так что пакет аргументов) не будет лучше подходит для разрешения перегрузки. Следовательно, вышеприведенная резервная версия operator != будет выбрана только тогда, когда не будет лучшей перегрузки. Более того, он будет выбран, только если символ типа can_equal<> вернет true.
Я тестировал это против подготовленного вами SSCCE, где четыре struct определены вместе с некоторыми перегрузками operator == и operator !=:
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; }
Чтобы убедиться, что вы хотите получить нужный результат и зеркалировать то, что вы сделали в исходной версии резервной operator !=, я добавил распечатку на is_not_equal():
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
Что касается первого теста, operator != определяется для типа test, поэтому строка #1 должна печатать:
(!==)1
Что касается второго теста, operator != не определен для test3, а test3 не конвертируется в test4, поэтому наш глобальный operator != должен вступить в игру и отрицать результат перегрузки operator ==, который принимает два const test3&. Поэтому строка #2 должна печатать:
!(==)0 // operator == returns true, and is_not_equal() negates it
Наконец, третий тест включает в себя два объекта rvalue типа test4, для которых operator != определен (поскольку аргументы конвертируются в test4 const&). Поэтому строка #3 должна печатать:
(!=)1
И вот пример live, показывающий, что полученный результат является ожидаемым.