关系运算符实现困境

Question

我在设计几类需要支持运营商的过程中!=,>,<=,和>=.这些运营商将在运营商==和运营商方面实施<.

在这个阶段,我需要在继承std::rel_ops¹ 和迫使消费者使用²"手动" 之间做出选择.

[1]继承(可能的实现):

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

    friend bool operator!=(const T& lhs, const T& rhs) {return !(lhs == rhs);}
    friend bool operator>(const T& lhs, const T& rhs) {return (rhs < lhs);}
    friend bool operator<=(const T& lhs, const T& rhs) {return !(rhs < lhs);}
    friend bool operator>=(const T& lhs, const T& rhs) {return !(lhs < rhs);}
};

template<typename T> class Foo : RelationalOperatorsImpl< Foo<T> >
{
    public:
    explicit Foo(const T& value) : m_Value(value) {}

    friend bool operator==(const Foo& lhs, const Foo& rhs) {return (lhs.m_Value == rhs.m_Value);}
    friend bool operator<(const Foo& lhs, const Foo& rhs) {return (lhs.m_Value < rhs.m_Value);}

    private:
    T m_Value;
};

[2] std::rel_ops胶水:

template<typename T> class Foo
{
    public:
    explicit Foo(const T& value) : m_Value(value) {}

    friend bool operator==(const Foo& lhs, const Foo& rhs) {return (lhs.m_Value == rhs.m_Value);}
    friend bool operator<(const Foo& lhs, const Foo& rhs) {return (lhs.m_Value < rhs.m_Value);}

    private:
    T m_Value;
};

void Consumer()
{
    using namespace std::rel_ops;

    //Operators !=, >, >=, and <= will be instantiated for Foo<T> (in this case) on demand.
}

我基本上试图避免代码重复.关于哪种方法"感觉"更好的任何想法？

Answer 1

您是否考虑过使用boost,并让您的类继承boost::less_than_comparable<T>并且boost::equality_comparable<T>？它类似于你的第一个建议,有一些优点和缺点.优点:避免代码重复; 缺点:创建对boost的依赖.

由于boost是一个非常常见的C++库(如果你还没有使用它,你应该认真考虑开始使用它),con因子是暗淡的.