1

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

但这看起来很糟糕。有没有更清洁的方法来解决这个问题？

4

2 回答 2

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;
};

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

于 2012-08-19T03:05:55.537 回答
0

使用虚拟比较器进行单次调度和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用于返回符合 JavaComparable和 Cqsort()语义的值。

于 2012-08-19T03:26:03.240 回答