使用派生参数覆盖函数

Question

我想创建一个碰撞系统，其中一个基类代表场景中的一个对象，实现所有的碰撞逻辑，当检测到碰撞时，程序逻辑调用派生类函数。我面临的问题是，基类需要了解所有派生类，以便不同函数中的调度正常工作。

例如，基类，OnCollisionDetected 将被派生类覆盖以处理冲突

#include <iostream>

class BasePhysicsObject {
public:

    void Collides(BasePhysicsObject * another_object) {
        /* ... */
        bool collides = true;

        if (collides) this->OnCollisionDetected(another_object);
        return;
    }

    /* Function to be overriden */
    virtual void OnCollisionDetected(BasePhysicsObject * another_object) = 0;
};

场景中的两个虚拟类，重写了函数 OnCollisionDetected(BasePhysicsObject * another_object)，根据 this 参数将调用分派给适当的函数。

class Fire;

class Player : public BasePhysicsObject {
public:

    virtual void OnCollisionDetected(BasePhysicsObject * another_object) {
        /* double dispatch to specific implementation */
        another_object->OnCollisionDetected(this);
    }

    virtual void OnCollisionDetected(Fire * fire) {
        /* Collision with fire object*/
    }
};

class Fire : public BasePhysicsObject {
public:

    virtual void OnCollisionDetected(BasePhysicsObject * another_object) {
        /* double dispatch to specific implementation */
        another_object->OnCollisionDetected(this);
    }

    virtual void OnCollisionDetected(Player * player) {
        /* Collision with player object */
    }
};

主函数创建两个对象，并检查它们的碰撞。

int main(int argc, char ** argv){

    Player * player = new Player();
    Fire * fire = new Fire();

    fire->Collides(player);
}

最终发生的事情是，从Collides() 调用的Fire::OnCollisionDetected(BasePhysicsObject * another_object) 不会调用以派生类为参数的函数，即Player::OnCollisionDetected(Fire * fire)，而是再次回调函数的Player::OnCollisionDetected(BasePhysicsObject * another_object)，导致在堆栈溢出中。 据我了解，为了使双重分派工作，我需要在所有派生类的基类中声明OnCollisionDetected(Derived *)，但这是一个令人生畏的解决方案。还有其他方法吗？

Answer 1

对于双重调度模式，您必须有一个虚拟调度程序。 第一次调度是通过对 lhs 实例的虚拟调用完成的，这比使用 rhs 实例的调度要好：

class BasePhysicsObject {
public:
    virtual ~BasePhysicsObject() = default;

    virtual void CollideDispatcher(BasePhysicsObject* ) = 0;

    // The true collision code.
    virtual void OnCollisionDetected(Fire*) = 0;
    virtual void OnCollisionDetected(Player*) = 0;
};

class Player : public BasePhysicsObject {
public:
    // Always same implementation
    // but `this` type is different for each class
    // Which allow correct overload resolution
    void CollideDispatcher(BasePhysicsObject* rhs) override { rhs->OnCollisionDetected(this); }

    void OnCollisionDetected(Fire* rhs) override { /* Player/Fire collision */ }
    void OnCollisionDetected(Player* rhs) override { /*Player/Player collision*/ }
};

class Fire : public BasePhysicsObject {
public:
    // Always same implementation
    // but `this` type is different for each class
    // Which allow correct overload resolution
    void CollideDispatcher(BasePhysicsObject* rhs) override { rhs->OnCollisionDetected(this); }

    void OnCollisionDetected(Fire* rhs) override { /* Fire/Fire collision */ }
    virtual void OnCollisionDetected(Player* rhs) override {
         // Fire/Player collision:
         // might be symmetrical to Player/Fire collision and so:
         rhs->OnCollisionDetected(this);
    }
};