how to refer to the current struct in an overloaded operator?

Question

Hi!

I have a struct for which i want to define a relative order by defining < , > , <= and >= operators. actually in my order there won't be any equality, so if one struct is not smaller than another, it's automatically larger.

I defined the first operator like this:

struct MyStruct{
...
...

bool operator < (const MyStruct &b) const {return (somefancycomputation);}

};

now i'd like to define the other operators based on this operator, such that <= will return the same as < and the other two will simply return the oposite. so for example for the > operator i'd like to write something like

bool operator > (const MyStruct &b) const {return !(self<b);}

but i don't know how to refere to this 'self' since i can refere only to the fields inside the current struct.

whole is in C++

hope my question was understandable :)

thank you for the help!

Answer 1

Self is *this.

That is, this is a pointer to the current object, so you need to dereference it to get the actual object.

Answer 2

Overloaded operator is just a member function though with a fancy syntax. You can explicitly call it like this:

this->operator<( b );

or save yourself some hair :) and just provide int compare( const MyStruct& ) member function and use that in all the non-member comparison operators.

Answer 3

this is a pointer to your current object. So (as @Dave Hinton says) you'd have to dereference it. But, theres another option

Two options:

return !(*this<b)

or

return (!this->operator<(b))

Yes, the first one is quite nicer.

Answer 4

actually in my order there won't be any equality, so if one struct is not smaller than another, it's automatically larger.

That's a problem. C++ operations (and many algorithms) require a strict weak ordering, which (among others) implies that x == x holds for any x. More generally:

not (x < y) and not (y < x)

implies

x == y

for any x and y. In other words: you most probably must define some kind of equality for your struct to work with any conventional algorithm.

Answer 5

If you are providing an operator< with all the appropriate logic then (whether or not it is implemented as a free function) you can implement the other operators in terms of it as free functions. This follows the rule of preferring non-members over members where possible and free functions will have identical behaviour w.r.t. conversions of the left and right operands, whereas operators implemented as member functions don't.

e.g.

inline bool operator>(const MyStruct& a, const MyStruct&b)
{
    return b < a;
}

inline bool operator<=(const MyStruct& a, const MyStruct&b)
{
    return !(b < a);
}

inline bool operator>=(const MyStruct& a, const MyStruct&b)
{
    return !(a < b);
}

Answer 6

I'm with Tom/Dave above in that the direct way to write this:

return !(*this<b);

but for me the most explicitly clear form is:

return !operator<(b);

and Tom's: return !(this->operator<(b)); seems a little silly.

This little bit nasty C preprocessor code (I also have a better but more technical template solution):

#define CREATE_SYMETRIC_ORDINAL_OPERATORS(Type) \
int operator !=(Type X) {return !((*this)==X); } \
int operator <(Type X) {return !((*this)>=X); } \
int operator >=(Type X) {return (((*this)>X)||((*this)==X)); } \
int operator <=(Type X) {return (((*this)<X)||((*this)==X)); }

automatically defines all comparison operators assuming == and > are defined like so:

class Comparable {
  public:
    int operator ==(Comparable B);
    int operator >(Comparable B);
    CREATE_SYMETRIC_OPERATORS(Comparable);
};

Answer 7

This is meant as a slight improvement over Element's answer:

template< class Derived >
class Comparable {
  public:
    bool operator !=(const Derived& rhs) const
    {return !( static_cast<Derived&>(*this) == rhs ); }

    bool operator <(const Derived& rhs) const
    {return rhs < static_cast<Derived&>(*this); } 

    bool operator >=(const Derived& rhs) const
    {return !( static_cast<Derived&>(*this) < rhs ); }

    bool operator <=(const Derived& rhs) const
    {return !( static_cast<Derived&>(*this) > rhs ); }
};

struct MyStruct : public Comparable<MyStruct> {
    bool operator ==(const MyStruct & rhs) const
    {return /* whatever */; }

    bool operator <(const MyStruct & rhs) const
    {return /* whatever */; }
};