Question

我有一个结构，我想通过定义＆lt;来定义相对顺序。，＆gt; ，＆lt; =和＆gt; =运营商。实际上在我的顺序中不会有任何相等，所以如果一个结构不小于另一个结构，它会自动变大。

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

struct MyStruct{
...
...

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

};

现在我想根据这个运算符定义其他运算符，这样＆lt; =将返回与＆lt;而另外两个将简单地返回对面。例如，对于＆gt;我想写一些像

这样的东西

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

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

整体是在C ++中

希望我的问题可以理解：）

谢谢你的帮助！

Answer 1

自我为*this。

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

Answer 2

如果您正在为operator<提供所有适当的逻辑（无论它是否作为自由函数实现），您可以将其他运算符实现为自由函数。这遵循以下规则：在可能的情况下，非成员优先于成员，而自由职能将具有相同的行为w.r.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 3

这意味着比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 */; }
};

Answer 4

重载运算符只是一个成员函数，但具有花哨的语法。您可以这样明确地调用它：


this->operator<( b );

或保存自己的头发:)并提供int compare( const MyStruct& )成员函数并在所有非成员比较运算符中使用它。

Answer 5

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

两个选项：

return !(*this<b)

or

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

是的，第一个非常好。

Answer 6

实际上在我的顺序中不会有任何相等，所以如果一个结构不小于另一个结构，它会自动变大。

这是一个问题。 C ++操作（和许多算法）需要strict weak ordering，其中（{等式}）意味着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's：return！（this-＆gt; operator＆lt;（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)); }

假设==和＆gt;

自动定义所有比较运算符定义如下：

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

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

7 个答案: