是否可以不从 boost::operators 继承，但仍然使用它？

Question

根据boost documentation - boost::operators 的正确用法是从中派生：

class A : boost::operators<A>
{
public:
    bool operator < (const A&) const { return false; }
};

现在，我可以使用> 和<= 和>=，因为所有这些运算符都可以用< 实现，请参见boost 中的代码sn-p：

template <class T, class B = operators_detail::empty_base<T> >
struct less_than_comparable1 : B
{
     friend bool operator>(const T& x, const T& y)  { return y < x; }
     friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
     friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
};

最后less_than_comparable1 是boost::operators 基类之一。

问题： 但是添加这样的继承并不总是很方便。例如。这种继承意味着我必须向某些结构添加构造函数，否则所有旧代码，例如 A{1} 都会停止编译：

struct A : boost::operators<A>
{
    A() = default;
    A(int a, int b = 0) : a(a), b(b) {}
    int a;
    int b;
};
bool operator < (const A&, const A&);

我尝试了几种方法：内部类，boost::operators<A> 的静态成员，但似乎只有继承有效。

---

我接受一个答案，该答案显示了如何在没有继承的情况下使用 boost::operators。
我也可以接受一个答案，它解释了为什么需要这种继承。

---

好的，让我们稍微简化一下这个例子，为什么我需要在下面这个例子中继承才能从operator < 获取operator >？

template <typename A>
struct GtOperator
{
    friend bool operator > (const A& l, const A& r)
    {
        return r < l;
    }
};

struct A : private GtOperator<A>
{
    bool operator < (const A&) const
    {
        return false;
    }
};

int main() {
    if (A{} > A{})
    {
        return -1;
    }
}

似乎没有其他工作，例如这种方式行不通：

struct A
{
    GtOperator<A> dummy;

    bool operator < (const A&) const
    {
        return false;
    }
};

Answer 1

是否可以不继承boost::operators，但仍然使用它？

不，基本上。它的目的是继承自。它起作用的原因是，依赖于参数的查找只会在 关联类 ([basic.lookup.argdep]/4) 中查找友元函数和函数模板 - 这将是 A 和A 的基类。如果boost::operators<A> 不是A 的基类，则无法通过名称查找找到其friend 函数。

即使在 C++17 中使用新的聚合初始化规则，A{1,2} 也会中断，因为您必须编写 A{{},1,2}。

您最好的选择可能是编写一个宏，该宏作为一个 mixin 可以有效地完成同样的事情。所以订购的将是：

#define LESS_THAN_COMPARABLE(T) \
 friend bool operator>(const T& x, const T& y)  { return y < x; } \
 friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); } \
 friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }

class A
{
public:
    bool operator < (const A&) const { return false; }
    LESS_THAN_COMPARABLE(A)
};

是的，那很糟糕。 （这些也可以定义为非成员函数，只需删除 friend 并将宏调用放在类之外）。

另一种选择，除了添加构造函数和编写宏之外，是希望<=> 能够实现，然后等待几年才能使用它。