如何在重载运算符中引用当前结构？

Question

我有一个结构体，我想通过定义 << 来定义相对顺序。 ，> 、<= 和 >= 运算符。实际上，按照我的顺序，不会有任何相等，因此如果一个结构不小于另一个结构，它会自动更大。

我像这样定义了第一个运算符：

struct MyStruct{
...
...

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

};

现在我想基于这个运算符定义其他运算符，这样 <= 将返回与 <= 相同的结果。另外两个只会返回相反的结果。 例如对于 >我想写一些类似的东西

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

，但我不知道如何引用这个“self”，因为我只能引用当前结构内的字段。

整个都是用 C++ 写的，

希望我的问题可以理解:)

谢谢你的帮助！

Answer 1

自我是*this。

也就是说，this 是一个指向当前对象的指针，因此您需要取消引用它才能获取实际的对象。

Answer 2

如果您提供具有所有适当逻辑的运算符<，那么（无论它是否作为自由函数实现）您可以将其他运算符作为自由函数实现。这遵循在可能的情况下优先选择非成员而不是成员的规则，并且自由函数在左右操作数的转换方面将具有相同的行为，而作为成员函数实现的运算符则不然。

例如

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 3

这意味着对 元素的答案：

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 */; }
};

Answer 4

重载运算符只是一个成员函数，尽管语法很奇特。
您可以像这样显式调用它：

this->operator<( b );

或者为自己节省一些头发:)，只需提供 intcompare( const MyStruct& ) 成员函数并在所有非成员比较运算符中使用它。

Answer 5

这是指向当前对象的指针。所以（正如 @Dave Hinton 所说）你必须取消引用它。但是，还有另一种选择

两种选择：

return !(*this<b)

or

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

是的，第一个更好。

Answer 6

实际上，按照我的顺序，不会有任何相等，因此如果一个结构不小于另一个结构，它会自动更大。

这是一个问题。 C++ 操作（以及许多算法）需要严格的弱排序，其中（其他）意味着 x == x 对于任何 x 都成立。更一般地说：

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

暗示

x == y

任何x和y。换句话说：您很可能必须为您的结构定义某种等式才能与任何传统算法一起使用。

Answer 7

我同意上面的 Tom/Dave 的直接写法：

return !(*this<b);

但对我来说，最明确清晰的形式是：

return !operator<(b);

和 Tom 的： return !(this->operator<(b));似乎有点傻。

这个有点讨厌的 C 预处理器代码（我还有一个更好但更具技术性的模板解决方案）：

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

自动定义所有比较运算符，假设 == 和 >定义如下：

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