继承类中的比较运算符

Question

我定义了一个IntWrapper 类，如下所示：

struct IntWrapper
{
protected:
  int value;

public:
  explicit IntWrapper() = default;
  explicit IntWrapper(const int value) : value(value) {}

  bool operator< (const IntWrapper rhs) const { return value <  rhs.value; }
  bool operator> (const IntWrapper rhs) const { return value >  rhs.value; }
  bool operator<=(const IntWrapper rhs) const { return value <= rhs.value; }
  bool operator>=(const IntWrapper rhs) const { return value >= rhs.value; }
  bool operator==(const IntWrapper rhs) const { return value == rhs.value; }

  explicit operator int() const { return value; }
};

以及继承自 IntWrapper 的类 Foo 和 Bar

struct Foo: IntWrapper
{
  using IntWrapper::IntWrapper;
};

struct Bar: IntWrapper
{
  using IntWrapper::IntWrapper;
};

我只想比较相同类型的对象。换句话说，我希望下面的代码给出编译错误，而不是将 foo 和 bar 转换为 IntWrapper。

const Foo foo(1);
const Bar bar(2);
bool b = foo >= bar;

由于我有许多其他对象，例如 Foo 和 Bar，有什么方法可以实现我的结果，将所有比较运算符保留在 IntWrapper 中？

Answer 1

您可以向您的IntWrapper 添加一个虚拟模板，以使比较运算符仅适用于相同类型的IntWrapper：

template<class>
struct IntWrapper
{ /* same code */ };

struct Foo : IntWrapper<Foo> { using IntWrapper::IntWrapper; };
struct Bar : IntWrapper<Bar> { using IntWrapper::IntWrapper; };

int main()
{
    const Foo foo(1);
    const Bar bar(2);
    //bool b = foo >= bar; // error: no match for 'operator>=' (operand types are 'const Foo' and 'const Bar')
}

live demo

Answer 2

我只想比较相同类型的对象。

如果您希望两个 IntWrapper 实例具有可比性，但不是从 IntWrapper 继承的类的实例，您实际上是在说您并不真的希望这些类从 IntWrapper 继承。

• @YSC suggested 你使用 CRTP 模式阻止了这种继承，这样每个类都继承了它“自己的”IntWrapper。这样可以防止代码重复。
• 您可以更改比较运算符，使其检查是否属于同一 IntWrapper 子类的元素。
• 您可以将可比性归结为 IntWrapper 的子类，Foo 和 Bar 不继承该子类。

而且可能还有更多方法可以实现这一点。但是，再一次，这听起来像是一个有问题的设计。

Answer 3

为这些运算符使用模板并将它们声明为朋友。

template <typename T, 
          std::enable_if_t<std::is_base_of_v<IntWrapper, T>, int> = 0> 
friend bool operator< (T lhs, T rhs) { return lhs.value <  rhs.value; }

现在如果参数的真实类型不同，T 就无法正确推导出来。

---

注意我不使用const T，因为top-level const of function parameter is ignored。