当我事先不知道所有类时，如何实现双重调度？

我有一个基类，它（可能）有很多子类，我希望能够比较基类的任何两个对象以获得相等性。我试图在不调用亵渎typeid关键字的情况下做到这一点。

#include <iostream>
struct Base {
    virtual bool operator==(const Base& rhs) const
        {return rhs.equalityBounce(this);}
    virtual bool equalityBounce(const Base* lhs) const = 0;
    virtual bool equalityCheck(const Base* lhs) const = 0;
};
struct A : public Base {
    A(int eh) : a(eh) {}
    int a;
    virtual bool equalityBounce(const Base* lhs) const{
        return lhs->equalityCheck(this);
    }
    virtual bool equalityCheck(const Base* rhs) const {return false;}
    virtual bool equalityCheck(const A* rhs) const {return a == rhs->a;}
};

int main() {
    Base *w = new A(1), *x = new A(2);
    std::cout << (*w == *w) << "n";
    std::cout << (*w == *x) << "n";
}

我知道编写的代码是失败的，因为equityBounce（）中的lhs是Base*，所以它甚至不知道equityCheck（）的哪个版本需要a*。但我不知道该怎么办。

为什么它不起作用

双调度实现的问题在于，您期望调用最特定的equalityCheck()。

但是您的实现完全基于多态基类，并且equalityCheck(const A*)重载，但不会覆盖equalityCheck(const Base*)！

Otherhise说，在编译时，编译器知道A::equalityBounce()可以调用equalityCheck(A*)（因为this是A*），但不幸的是，它调用的Base::equalityCheck()没有A*参数的专用版本。

如何实现

为了使双分派工作，您需要在基类中具有双分派equityCheck（）的特定类型实现。

要做到这一点，基地需要意识到它的后代：

struct A; 
struct Base {
    virtual bool operator==(const Base& rhs) const
    {
        return rhs.equalityBounce(this);
    }
    virtual bool equalityBounce(const Base* lhs) const = 0;
    virtual bool equalityCheck(const Base* lhs) const = 0;
    virtual bool equalityCheck(const A* lhs) const = 0;
};
struct A : public Base {
    ...
    bool equalityBounce(const Base* lhs) const override{  
        return lhs->equalityCheck(this);
    }
    bool equalityCheck(const Base* rhs) const override {
        return false; 
    }
    bool equalityCheck(const A* rhs) const override{
        return a == rhs->a;
    }
};

请注意override的使用，以确保函数真正覆盖基的虚拟函数

有了这个实现，它将发挥作用，因为：

A::equalityBounce()将呼叫Base::equalityCheck()
在该函数的所有重载版本中，它将选择Base::equalityCheck(A*)，因为this是A*
被调用的CCD_ 16对象将调用其CCD_。如果lhs是A*，则它将因此进行A::equalityCheck(A*)，这将产生期望的（正确的）结果祝贺
假设CCD_ 21将是指向同样从CCD_ 23导出的另一类CCD_。在这种情况下，lhs->equalityCheck(A*)将调用X::equalityCheck(A*)，并且还可以返回正确的响应，考虑到您将比较X和A

如何使其可扩展？双重调度地图

使用强类型语言进行双重分派的问题在于，"反弹"对象需要知道如何与特定（预先已知）类进行比较。由于源对象和反弹对象具有相同的多态基类型，因此基需要知道所有涉及的类型。这种设计严重限制了可扩展性。

如果你想在基类中添加任何派生类型，而不需要事先知道它，那么你必须遍历动态类型（无论是dynamic_cast还是typeid）：

我在这里向你提出一个关于动态可扩展性的建议。它使用单一调度来比较相同类型的两个对象，并使用双重调度映射来比较它们之间的不同类型（如果未声明任何内容，则默认返回false）：

struct Base {
    typedef bool(*fcmp)(const Base*, const Base*);  // comparison function
    static unordered_map < type_index, unordered_map < type_index, fcmp>> tcmp;  // double dispatch map
    virtual bool operator==(const Base& rhs) const
    {
        if (typeid(*this) == typeid(rhs)) {  // if same type, 
            return equalityStrict(&rhs);     // use a signle dispatch
        }
        else {                              // else use dispatch map.  
            auto i = tcmp.find(typeid(*this));
            if (i == tcmp.end() ) 
                return false;              // if nothing specific was foreseen...
            else {
                auto j = i->second.find(typeid(rhs));
                return j == i->second.end() ? false : (j->second)(this, &rhs);
            }
        }
    }
    virtual bool equalityStrict(const Base* rhs) const = 0;  // for comparing two objects of the same type
};

然后，A类将被重写为：

struct A : public Base {
    A(int eh) : a(eh) {}
    int a;
    bool equalityStrict(const Base* rhs) const override {  // how to compare for the same type
        return (a == dynamic_cast<const A*>(rhs)->a); 
        }
};

使用此代码，您可以将任何对象与相同类型的对象进行比较。现在为了展示可扩展性，我创建了一个struct X，其成员与A相同。如果我想让A和X共付，我只需要定义一个比较函数：

bool iseq_X_A(const Base*x, const Base*a) {
    return (dynamic_cast<const X*>(x)->a == dynamic_cast<const A*>(a)->a);
}  // not a member function, but a friend.

然后，为了使动态双调度工作，我必须将此功能添加到双调度图中：

Base::tcmp[typeid(X)][typeid(A)] = iseq_X_A;

那么结果很容易验证：

Base *w = new A(1), *x = new A(2), *y = new X(2);
std::cout << (*w == *w) << "n";  // true returned by A::equalityStrict
std::cout << (*w == *x) << "n";  // false returned by A::equalityStrict 
std::cout << (*y == *x) << "n";  // true returned by isseq_X_A

如果您需要一个虚拟的equals运算符，并且希望避免dynamic_cast，则可以向基类中添加一个指示类型的枚举类型，并生成一个虚拟getter，然后在匹配的情况下执行静态强制转换。

enum ClassType { AType, BType };
Class A 
{
public:
virtual ClassType getType ();
virtual bool operator ==(const A& a ) const;
};
// in B implementation
virtual bool B::operator ==(const A& a)
{
if (!A::operator==(a)) return false;
if(a.getType () != ClassType::BType) return false;
const B& b = static_cast <const& B>(a);
// do B == checks
return true;
}

尽管由于dynamic_cast的原因速度较慢，但我认为最舒适的解决方案是下一个：

#include <iostream>
struct Base {
    virtual bool operator==(const Base& rhs) const
    { return equalityBounce(&rhs); }
    virtual bool equalityBounce(const Base* lhs) const = 0;
};
template<typename Derived>
struct BaseHelper : public Base
{
    bool equalityBounce(const Base* rhs) const
    {
        const Derived* p_rhs = dynamic_cast<const Derived*>(rhs);
        if (p_rhs == nullptr)
            return false;
        else
            return p_rhs->equalityCheck
             (reinterpeter_cast<const Derived*>(this));
    }
    virtual bool equalityCheck(const Derived*) const = 0;
};
struct A : public BaseHelper<A> {
    A(int eh) : a(eh) {}
    int a;
    virtual bool equalityCheck(const A* rhs) const
    { return a == rhs->a; }
};

int main() {
   Base *w = new A(1), *x = new A(2);
   std::cout << (*w == *w) << "n"; // Prints 1.
   std::cout << (*w == *x) << "n"; // Prints 0.
}

通过这种方式，您只需要关心比较与"me"相同派生类型的对象。您不需要编写更多的重载，因为BaseHelper为您提供了所有的辅助工作。

相关内容

最新更新

热门标签：