Question

我正在使用双重调度来获取作为另一个（A）的子类的2个类（B，C）的2个对象之间的距离。我认为class A中的方法应该是纯虚拟的，但是它们在其他地方的测试中使用，所以class A必须是可实例化的，所以我不能让它们成为纯虚拟的，对吗？

另一件事是我不确定我是否正在以一种好的方式使用双重调度，因为有时会在基类的Distance(A *a)定义中生成一个无限循环。

在class A中，我有方法：

virtual double Distance(A *a)  {return a->Distance(this);}
virtual double DistanceB(B *b) {return std::numeric_limits<double>::max();}
virtual double DistanceB(C *c) {return std::numeric_limits<double>::max();}
virtual double DistanceC(B *b) {return std::numeric_limits<double>::max();}
virtual double DistanceC(C *c) {return std::numeric_limits<double>::max();}

在class B：

中

double B::Distance(A *a)  { return a->DistanceB(this); }
double B::DistanceB(B *b) { /*calculate distance*/ }
double B::DistanceC(C *c) { return c->DistanceB(this); }

在class C：

中

double C::Distance(A *a)  { return a->DistanceC(this); }
double C::DistanceB(B *b) { /*calculate distance*/ }
double C::DistanceC(C *c) { /*calculate distance*/ }

Answer 1

virtual double Distance(A *a)
{return a->Distance(this);}

所以，如果我有：

A* a1, a2;

我打电话给：

a1->Distance(a2);

上述实施将致电

a2->Distance(a1);

将致电：

a1->Distance(a2);

......这是一个无限循环。

Answer 2

由于A不是纯粹的摘要，您还必须提供：

virtual double DistanceA(A *a);
virtual double DistanceA(B *b);
virtual double DistanceA(C *c);
virtual double DistanceB(A *a);
virtual double DistanceC(A *a);

并修复

double A::Distance(A *a) {return a->DistanceA(this); }

双调度无限循环

2 个答案: