具有不一致排序推导的三向比较运算符

问题描述

前段时间我定义了我的第一个三向比较运算符。它比较了单一类型并取代了多个常规运算符。很棒的功能。然后我尝试实现一个类似的操作符，通过委托比较两个变体：

auto operator <=> (const QVariant& l,const QVariant& r)
{   
   switch (l.type())
   {
      case QMetaType::Int:
         return l.toInt() <=> r.toInt();
      case QMetaType::Double:
         return l.todouble() <=> r.todouble();
      default:
         throw;
   }
}

这不编译，我收到错误

自动返回类型的不一致扣除：‘std::strong_ordering’然后是‘std::partial_ordering’。

显然 int 和 double 飞船操作符返回不同的类型。

解决这个问题的正确方法是什么？

解决方法

以相同的方式解析任何其他返回 auto 的函数，其中不同的 return 语句推导出不同。你要么：

确保所有 return 具有相同的类型，或
明确选择返回类型。

在这种情况下，ints 比较为 strong_ordering 而 doubles 比较为 partial_ordering，并且 strong_ordering 可以隐式转换为 partial_ordering ，您可以执行以下任一操作：

std::partial_ordering operator <=>(const QVariant& l,const QVariant& r) {
    // rest as before
}

或显式转换整数比较：

      case QMetaType::Int:
         return std::partial_ordering(l.toInt() <=> r.toInt());

这为您提供了一个返回 partial_ordering 的函数。

如果您想返回 strong_ordering，则必须将 double 比较提升到更高的类别。您可以通过两种方式做到这一点：

您可以使用 std::strong_order，这是一种开销更大的操作，但提供所有浮点值的总排序。然后你会写：

      case QMetaType::Double:
         return std::strong_order(l.toDouble(),r.toDouble());

或者你可以做一些事情，比如认为 NaN 的格式不正确并以某种方式将它们扔掉：

      case QMetaType::Double: {
         auto c = l.toDouble() <=> r.toDouble();
         if (c == std::partial_ordering::unordered) {
             throw something;
         } else if (c == std::partial_ordering::less) {
            return std::strong_ordering::less;
         } else if (c == std::partial_ordering::equivalent) {
            return std::strong_ordering::equal;
         } else {
            return std::strong_ordering::greater;
         }
      }

比较繁琐，但我不确定是否有更直接的方法来进行这种提升。

operator<=> 和 int 的 double 的类型不同，但它们应该有一个共同的类型。您可能希望利用编译器自动查找正确的类型。您可以使用 std::common_type 来做，但这会很丑陋。仅利用 std::common_type 类型在（在库中而不是编译器中实现时）的作用并使用三元运算符会更容易：

auto operator <=> (const QVariant& l,const QVariant& r)
{   
    return l.type() == QMetaType:Int? l.toInt() <=> r.toInt()
         : l.type() == QMetaType::Double? l.toDouble() <=> r.toDouble()
         : throw;
}

我尝试了一些模板代码来实现 Dietmar Kühls 使用 std::common_type 的想法。这是结果示例代码：

template <typename CommonT,typename... ArgsT> requires (sizeof...(ArgsT) == 0)
inline CommonT variantSpaceshipHelper([[maybe_unused]] const QVariant& pLeft,[[maybe_unused]] const QVariant& pRight) noexcept
{
   std::terminate(); // Variant type does not match any of the given template types
}

template <typename CommonT,typename T,typename... ArgsT>
inline CommonT variantSpaceshipHelper(const QVariant& pLeft,const QVariant& pRight) noexcept
{
   if (pLeft.type() == static_cast<QVariant::Type>(qMetaTypeId<T>()))
   {
      return (pLeft.value<T>() <=> pRight.value<T>());
   }

   return variantSpaceshipHelper<CommonT,ArgsT...>(pLeft,pRight);
}

template <typename... ArgsT>
inline auto variantSpaceship(const QVariant& pLeft,const QVariant& pRight) noexcept
{
   using CommonT = std::common_type_t<decltype(std::declval<ArgsT>() <=> std::declval<ArgsT>())...>;
   return variantSpaceshipHelper<CommonT,pRight);
}

inline auto operator <=>(const QVariant& pLeft,const QVariant& pRight) noexcept
{
   assert(pLeft.type() == pRight.type());
   return variantSpaceship<int,double>(pLeft,pRight);
}

可以轻松地将其他类型添加到 variantSpaceship 调用中。

c++c++20 qt return-type-deduction spaceship-operator