在抽象基类上实现运算符<

Implementing operator< on abstract base class

本文关键字：lt 运算符 实现 抽象 基类      更新时间：2023-10-16

我有一个类型层次结构，我不确定实现operator<和operator==的干净/好方法。

从本质上讲，我已经有了这个：

class Parent {
    public:
        virtual ~Parent() {}
};
class A : public Parent { int         data; };
class B : public Parent { double      data; };
class C : public Parent { std::string data; };
bool operator==(A const & lhs, A const & rhs) { return lhs.data == rhs.data; }
bool operator< (A const & lhs, A const & rhs) { return lhs.data <  rhs.data; }
bool operator==(B const & lhs, B const & rhs) { return lhs.data == rhs.data; }
bool operator< (B const & lhs, B const & rhs) { return lhs.data <  rhs.data; }
bool operator==(C const & lhs, C const & rhs) { return lhs.data == rhs.data; }
bool operator< (C const & lhs, C const & rhs) { return lhs.data <  rhs.data; }

我还想实现的是：

bool operator==(Parent const & lhs, Parent const & rhs) { ... }
bool operator< (Parent const & lhs, Parent const & rhs) { ... }

我目前已通过以下方式实现它：

bool operator==(Parent const & lhs, Parent const & rhs) {
    try {
        return dynamic_cast<A const &>(lhs) == dynamic_cast<A const &>(rhs);
    } catch(std::bad_cast const & e) {
    }
    try {
        return dynamic_cast<B const &>(lhs) == dynamic_cast<B const &>(rhs);
    } catch(std::bad_cast const & e) {
    }
    try {
        return dynamic_cast<C const &>(lhs) == dynamic_cast<C const &>(rhs);
    } catch(std::bad_cast const & e) {
    }
    assert(typeid(lhs) != typeid(rhs));
    return false;
}

但这似乎很糟糕。有没有更清洁的方法

？

对于复杂类型的比较，您可能会发现双重调度很有用。

如果您的类型非常简单，有时将它们全部合并为一个是有效的。在 3 个无符号变体的示例中，最好只使用一种类型来适应所有大小，并避免动态调度和更复杂的类型图。

应用于原始问题;其中 A、B 和 C 都使用无符号类型：

好吧，一种快速而肮脏的方法是：

class Parent {
protected:
  virtual ~Parent() {}
public:
  bool operator<(const Parent& pOther) const {
    return this->as_uint64() < pOther.as_uint64();
  }
  // ...
private:
  // using a type which accommodates all values
  virtual uint64_t as_uint64() const = 0;
};

然后从 Parent 派生的形式为：

class A : public Parent {
// ...
private:
    virtual uint64_t as_uint64() const { return this->data; }
private:
    uint16_t data;
};

然后Parent可以简单地定义所有比较器，并且所有Parent类型都是可比的。

使用虚拟比较器进行单次调度，使用虚拟比较器进行类型转换dynamic_cast：

class ABC_base {
public:
    virtual ~ABC_base() {} 
    bool operator < (ABC_base const & rhs) const {
        return this->comparator(rhs) < 0;
    }
protected:
    virtual int comparator (ABC_base const &) = 0;
};
class ABC : public ABC_base {
protected:
    virtual int comparator(ABC_base const & rhs) const {
        try {
            return my_comparator(dynamic_cast<ABC const&>(rhs));
         // Run-time cast failed - use double dispatch as fallback
         } catch (std::bad_cast&) {
             return -rhs.comparator(*this);
         }
     }
private:
    int my_comparator(ABC const & rhs) const {
        if (data < rhs.data)
            return -1;
        if (data == rhs.data)
            return 0;
        if (data > rhs.data)
            return 1;
    }
    T data;
};

以下是代码的工作原理：

调用基类的operator <，它使用动态查找来查找comparator。它检查返回的值以查看它是否较小。

派生类

的比较器尝试向下转换基类引用，以便可以对派生类的成员进行比较。

为什么使用基类引用，而不是使用派生类引用？否则，由于功能签名不正确，虚拟调度将无法工作。

如果向下转换成功，它将调用非虚拟专用比较器。否则，它将再次使用虚拟调度来执行(rhs ? *this)并否定结果以补偿倒置排序。

为什么不在一个虚拟函数中进行演员表和比较？这将使代码更加混乱，因为该函数将做两件事：强制转换和比较。因此，有一个专用比较器功能。如果要在派生类中使用基函数，请按照 class ABC_der : public ABC 的思路调用 ABC::comparator(static_cast<ABC const&>(rhs)) 。使用 Base:: 强制静态调度，因此您不必公开帮助程序比较函数。

现在，this和rhs属于同一类型，因此我们终于可以进行实际比较。if语句链用于返回符合 Java Comparable和 C qsort()语义的值。

相关文章：