Question

我有一个类型层次结构，我不确定实现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;
}

但这看起来很糟糕。是否有一种更清洁的方式来解决这个问题？

Answer 1

对于复杂类型的比较，您可能会发现Double Dispatch有用。

如果您的类型非常简单，有时将它们全部合并为一个有效。在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类型都具有可比性。

Answer 2

使用虚拟比较器进行单一调度，使用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)并取消结果以补偿反转顺序。

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

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

实施运算符＆lt;在抽象基类上

2 个答案: