C++ 关系运算符生成器

Question

一旦定义了< 运算符，您就可以估计其余关系运算符的行为方式。我正在尝试为我的课程实现一种方法。

我想要的是只定义 < 和其他隐式默认的运算符。到目前为止我得到的是这个设计，我将在下面详细说明：

template<typename T>
struct relational
{
    friend bool operator> (T const &lhs, T const &rhs) { return rhs < lhs; }
    friend bool operator==(T const &lhs, T const &rhs) { return !(lhs < rhs || lhs > rhs); }
    friend bool operator!=(T const &lhs, T const &rhs) { return !(rhs == lhs); }
    friend bool operator<=(T const &lhs, T const &rhs) { return !(rhs < lhs); }
    friend bool operator>=(T const &lhs, T const &rhs) { return !(lhs < rhs); }
};

因此，对于实现 < 运算符的类，它只需要从 relational 继承即可默认其余运算符。

struct foo : relational<foo>
{ 
    // implement < operator here
};

1. 有没有更好的设计替代品？

2. 这段代码中有定时炸弹吗？我假设如果用户想要为其中一个运算符定义自定义实现，重载决议将启动并选择非模板（用户定义）实现。如果不是这种情况（或者我会遇到从relational 继承的类模板的问题），我应该像这样实现relational 中的运算符吗？

   // inside the relational struct
   friend bool operator>(relational const &lhs, relational const &rhs)
   { // functions that involve implicit conversion are less favourable in overload resolution
           return (T const&)rhs < (T const&)lhs; 
   }
   

感谢您的建议，这里是demo of the code working

Answer 1

我通常使用从罗伯特·马丁那里学到的技巧来做到这一点。 我有一个模板类：

template <typename T>
class ComparisonOperators
{
protected:
    ~ComparisonOperators() {}

public:
    friend bool operator==( T const& lhs, T const& rhs )
    {
        return lhs.compare( rhs ) == 0;
    }
    friend bool operator!=( T const& lhs, T const& rhs )
    {
        return lhs.compare( rhs ) != 0;
    }
    friend bool operator<( T const& lhs, T const& rhs )
    {
        return lhs.compare( rhs ) < 0;
    }
    friend bool operator<=( T const& lhs, T const& rhs )
    {
        return lhs.compare( rhs ) <= 0;
    }
    friend bool operator>( T const& lhs, T const& rhs )
    {
        return lhs.compare( rhs ) > 0;
    }
    friend bool operator>=( T const& lhs, T const& rhs )
    {
        return lhs.compare( rhs ) >= 0;
    }
};

需要操作符的类派生自：

class Toto : public ComparisonOperators<Toto>
{
    // ...
public:
    //      returns value < 0, == 0 or >0, according to
    //      whether this is <, == or > other.
    int compare( Toto const& other ) const;
};

（我的实现实际上有点复杂，因为它 使用一些简单的元编程来调用isEqual，而不是 compare，如果该函数存在。）

编辑：

并重新阅读您的问题：这基本上就是您正在做的事情，这几乎是这类事情的标准习语。我更喜欢使用像compare 这样的命名函数，但这只是个人喜好。然而，处理isEqual 的元编程技巧值得费心：这意味着您可以对仅支持相等的类型使用相同的类；当编译器尝试实例化时，你会得到一个错误，例如operator<=，但编译器不会尝试实例化它，除非有人使用它。通常情况下，isEqual 可以比compare 更有效地实现。

编辑 2：

为了它的价值：我系统地做这件事。我也有 ArithmeticOperators（根据+=定义例如+）， MixedTypeArithmeticOperators（和上面一样，但是有两个 类型，T1，它是基类，T2；它 提供所有运算符的组合）。和 STLIteratorOperators，实现了 STL 迭代器 界面基于更合理、更容易上手的东西 实现（基本上，带有isEqual 的 GoF 迭代器 功能）。他们节省了很多样板文件。

编辑 3：

最后：我只是查看了工具包中的实际代码。 有条件地支持isEqual 甚至比 我记得：上面的模板类有一个公共成员：

bool isEqual( T const& other ) const
{
    return static_cast< T const* >( this )->compare( other ) == 0;
}

而operator== 和operator!= 只需使用isEqual，不 涉及模板元编程。如果派生类 定义了一个isEqual，它隐藏了这个，然后被使用了。如果 不，这个被使用了。

Answer 2

朋友不是继承的，所以这个想法行不通。但是，您可以巧妙地使用宏来代替，例如：

#define GEN(X) \
    friend bool operator> (T const &lhs, T const &rhs) { return rhs < lhs; } \
    friend bool operator==(T const &lhs, T const &rhs) { return !(lhs < rhs || lhs > rhs); } \
    friend bool operator!=(T const &lhs, T const &rhs) { return !(rhs == lhs); } \
    friend bool operator<=(T const &lhs, T const &rhs) { return !(rhs < lhs); } \
    friend bool operator>=(T const &lhs, T const &rhs) { return !(lhs < rhs); }

你可以用作：

class Foo
{
...
GEN(foo)
};