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

Question

According to boost documentation - proper usage of boost::operators is to derive from it:

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

Now, I can use > and <= and >= because all of these operators can be implemented with < , see code snippet from boost:

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); }
};

And finally less_than_comparable1 is one of boost::operators base class.

PROBLEM: But adding such inheritance is not always convenient. Eg this inheritance means I have to add constructor(s) to some structs, otherwise all old code, such as A{1} stops compiling:

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&);

I tried several ways: inner class, static members of boost::operators<A> but it seems that only inheritance works.

---

I accept an answer that shows the way how to use boost::operators without inheritance.
I can also accept an answer, that explains why this inheritance is needed.

---

Ok, let's simplify a little this example, why I need inheritance in this very example below to get operator > from 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;
    }
}

Nothing else seems to work, eg this way does not work:

struct A
{
    GtOperator<A> dummy;

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

Answer 1

Is it possible not to inherit from boost::operators , but still use it?

No, basically. It's intended to be inherited from. The reason it works is because argument-dependent lookup will only look for friend functions and function templates in associated classes ([basic.lookup.argdep]/4) - which are going to be A and A 's base classes. If boost::operators<A> isn't a base class of A , its friend functions won't be found by name lookup.

Even with new aggregate initialization rules in C++17, A{1,2} would break because you'd have to write A{{},1,2} .

Your best bet is probably to write a macro that functions as a mixin that effectively accomplishes the same thing. So the ordering ones would be:

#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)
};

Yes, that kind of sucks. (Also these could be defined as non-member functions as well, just drop the friend and put the macro invocation outside of the class).

The other alternative, besides adding constructors and writing macros, is to hope that <=> comes to fruition and then wait a few years to be able to use it.