[英]How can I implement double dispatch when I don't know all the classes in advance?
我有一个(可能)有很多子类的基类,并且我希望能够比较基类的任何两个对象是否相等。 我试图做到这一点而不调用亵渎性的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 *,所以它甚至不知道带有A *的equalCheck()的版本。 但是我不知道该怎么办。
如果您需要一个虚拟的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;
}
为什么它不起作用
双调度实现的问题在于,您希望调用最特定的equalityCheck()
。
但是,您的实现完全基于多态基类,并且equalityCheck(const A*)
重载但不会覆盖 equalityCheck(const Base*)
!
另一个说法是,在编译时,编译器知道A::equalityBounce()
可以调用equityCheck equalityCheck(A*)
(因为this
是一个A*
),但不幸的是,它调用的Base::equalityCheck()
没有针对A*
专门版本。 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*
Base *lhs
对象将调用其equalityCheck(A*)
。 如果lhs
是A*
则它将进行A::equalityCheck(A*)
,这将产生预期的(正确的)结果。 恭喜你! lhs
是指向另一个也从Base
派生的类X
的指针。 在这种情况下,考虑到将X
与A
进行比较, lhs->equalityCheck(A*)
将调用X::equalityCheck(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
由于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可以为您完成所有辅助工作。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.