派生对象之间的特殊交互（即多重调度）

Question

因此，我有一个基类指针列表：

list<Base*> stuff;

然后，在某个时刻，其中一个对象将查看所有其他对象。

Base * obj = ...; // A pointer from the 'stuff'-list.
for (list<Base*>::iterator it = stuff.begin(); it != stuff.end(); it++)
{
    if (obj == *it)
        continue;

    // Problem scenario is here
   obj->interact(it);
}

我想要实现的是，根据派生类型 obj 和 *it 的类型，它们之间的交互方式会有所不同，即 DerivedA 将如果与 DerivedB 交互，则销毁自身，但前提是 DerivedB 设置了属性 bool c = true;。所以就像这样：

struct Base 
{
    virtual void interact(Base * b); // is always called
};
struct DerivedA : public Base 
{
    virtual void interact(Base * b){} // is never called
    virtual void interact(DerivedB * b) // is never called
    {
        if (b->c)
            delete this;
    }
};
struct DerivedB : public Base 
{
    bool c = false;
    virtual void interact(Base * b){} // is never called
    virtual void interact(DerivedA * a) // is never called
    {
        c = true;
    }
};
// and many many more Derived classes with many many more specific behaviors.

在编译时，它们都是Base指针，并且无法相互调用并期望类型神奇地出现。如果这是一种单向关系，即我知道其中之一的类型，我可以使用 访客模式。我相信我应该使用某种 Mediator 模式 但无法真正弄清楚如何从中介者也将持有Base指针，因此不会产生任何影响。

我不知道如何继续...有人吗？

---

背景：

我正在创建一个游戏，此问题源自 Room 类，该类跟踪其内容，即当前的 GameObject 是什么在房间里。

有时，物体会移动（例如，玩家）。然后，房间将循环遍历即将移动的地砖上的所有对象（上面的循环），并检查这些对象是否会相互交互。

例如，如果它是一个巨魔，玩家就会想要伤害它。或者他只是想伤害任何源自于任何其他“团队”（可以通过所有Characters 实现的函数getAlignment() 访问）。

Answer 1

如果可以的话，请获取“更有效的 C++”的副本，并查看第 #31 项，它是关于实现多重分派的，这基本上就是您在这里寻找的内容。迈耶斯讨论了解决该问题的几种方法及其各种权衡。 （他甚至使用游戏作为示例。）

然而，也许他给出的最好建议是尝试重新设计代码以避免需要此功能。在本文中，还探讨了非成员函数方法，该方法的额外好处是消除了描述交互的每个函数应该属于哪个对象的问题。

Answer 2

我认为您建议的想法（使用 Base::interact）功能已基本完成。似乎唯一缺少的部分是：

在您的 Base 中，您需要拥有子类型的所有 interact 重载。考虑对 Base 结构的扩展：

struct DerivedA;
struct DerivedB;
struct Base 
{
    virtual void interact(Base * b); // *<->Base interaction
    virtual void interact(DerivedA * da); // *<->DerivedA interaction
    virtual void interact(DerivedB * db); // *<->DerivedB interaction
};

在 C++ 中实现双重调度是一件痛苦的事情：如果添加新的子类型，则必须触及层次结构的基础。

Answer 3

您将需要将相互交互的类型的所有可能组合实现为层次结构顶部的虚拟函数。
这是一个测试所有可能的交互的示例：

#include<iostream>
void say(const char *s){std::cout<<s<<std::endl;}
struct DerivedA;
struct DerivedB;
struct Base{
  virtual void interact(Base *b) = 0;

  virtual void interactA(DerivedA *b) = 0;
  virtual void interactB(DerivedB *b) = 0;

};
struct DerivedA : public Base 
{
  virtual void interact(Base *b){
    b->interactA( this ); 
  }
  virtual void interactA(DerivedA *b){
     say("A:A");
  }
  virtual void interactB(DerivedB *b){
     say("A:B");
  }
};
struct DerivedB:public Base{
  virtual void interact(Base *b){
    b->interactB( this ); 
  }
  virtual void interactA(DerivedA *b){
     say("B:A");
  }
  virtual void interactB(DerivedB *b){
     say("B:B");
  }
};

void interact(Base *b1,Base *b2){
  b1->interact( b2 );
}
main(){
  Base *a = new DerivedA;
  Base *b = new DerivedB();

  interact(a,b);
  interact(b,a);
  interact(a,a);
  interact(b,b);
}

Answer 4

第一：为什么使用struct而不是class？

第二：如果你使用 class 而不是 struct 你可以（必须）做这样的事情：

class Base 
{
    virtual void interact(Base * b); // see the VIRTUAL word (explained down)
}; 
class DerivedA : public Base 
{
    virtual void interact(DerivedB * b)
    {
        if (b->c)
            delete this;
    }
};
class DerivedB : public Base 
{
    bool c = false;
    virtual void interact(DerivedA * a)
    {
        c = true;
    }
};

使用 virtual 关键字是你需要的（我猜）。如果您将一个方法定义为虚拟，您会告诉“嘿！这可能已在某个地方被覆盖”，所以..当您编写此代码时：

DerivedA* a = new DerivedA();
DerivedB* b = new DerivedB();
a.interact(b); // here instead of calling Base::interact(Base*) call the override method in DerivedA class (because is virtual)

编辑：

忘记那个答案..（没有看到虚拟）

编辑2：

请参阅时装秀和弗里希·拉贝 答案。

Answer 5

您的 interact() 函数没有相同的签名：在派生类中，它们也应该是。

virtual void interact(Base * b);

virtual 当然是可选的，但为了清楚起见，我将它在那里。

要确定 DerivedA::interact() 是否应该对其参数执行某些操作，您可以在基类中实现另一个虚拟函数：

virtual canDoX(Base * b);
virtual canDoY(Base * b);

然后在派生实现中，它可能如下所示：

// DerivedA
void interact(Base * b)
{
    if (b->canDoX() && b->c)
        delete this;
}

// DerivedB
void interact(Base * b)
{
    if(b->canDoY())
        c = true;
}

更新：
既然您喜欢 Frerich Raabe 的回答，那么让我解释一下为什么我认为我的方法更好一些。
按照他的建议，必须为基类中的每个派生类以及可以与某个类交互的所有其他派生类创建一个 interact() 方法。
使用我的解决方案，必须为某些属性添加方法，这些方法也可以组合。
如果您有一个 Troll，它会在其 canBeKilled() 方法中返回 true。一个苹果 canBeEaten() 和一个美味的野生动物 canBeKilled()，然后是 canBeEaten()。
如果可以组合这些属性，则必须添加更少的功能。

此外：如果巨魔喝了一些灵丹妙药，使其在一段时间内处于无敌状态，它会返回 canBeKilled() == false 就是这样。您不必检查每个其他交互类中的 isInvulnerable() 标志。

Answer 6

我认为你的问题已经得到很好的讨论
Scott Meyer 的《Effective C++》如下：

规则：不要尝试使用基类指针访问派生类对象的数组 --> 结果将是未定义的。

我会给你一个例子：

struct Base{

virtual void print() { //in base }

virtual ~Base() {} //

}

struct Derived : public Base {

virtual void print(){ //in obliged }

}

void foo(基*pBase,int N)
{

for(int i=0; i<N ; i++)
   pBase[i].print(); // result will be undefined......

}

int main()
{

 Derived d[5];
 foo(&d,5); 

}

这种行为的原因是编译器在 sizeof(Base) 字节的跳转处找到下一个元素......

我想你明白我的意思......