访客模式的实现。小行星/宇宙飞船碰撞问题

Question

我尝试了解双重调度和访问者模式，但以下代码显然是错误的。我一定错过了一些明显的东西，但我不知道如何修复它。谁能照亮我吗？我不知道如何在访问者中放置具体实例，我应该在具体访问者类中创建一个构造函数吗？

interface Collidable
{
    void Accept(IVisitor other);
}

class Asteroid : Collidable
{
    public void Accept(IVisitor other)
    {
        Console.Write("[Asteroid] ");
        other.visitAsteroid(this);
    }
}

class Spaceship : Collidable
{
    public void Accept(IVisitor other)
    {
        Console.Write("[Spaceship] ");
        other.visitSpaceship(this);
    }
}

interface IVisitor
{
    void visitAsteroid(Asteroid a);
    void visitSpaceship(Spaceship s);
}

class CollisionWithAsteroidVisitor : IVisitor
{
    public void visitAsteroid(Asteroid a)
    {
        Console.WriteLine("Collided with asteroid");
    }

    public void visitSpaceship(Spaceship s)
    {
        Console.WriteLine("Collided with asteroid");
    }
}

class CollisionWithSpaceShipVisitor : IVisitor
{
    public void visitAsteroid(Asteroid a)
    {
        Console.WriteLine("Collided with spaceship");
    }

    public void visitSpaceship(Spaceship s)
    {
        Console.WriteLine("Collided with spaceship");
    }
}

    static void Main(string[] args)
    {
        Asteroid a1 = new Asteroid();
        Asteroid a2 = new Asteroid();
        Spaceship s1 = new Spaceship();
        Spaceship s2 = new Spaceship();

        s1.Accept(new CollisionWithAsteroidVisitor()); // this must be wrong
        s1.Accept(new CollisionWithSpaceShipVisitor()); // this must be wrong
    }

Answer 1

据我所知，您希望实现不同的物体可以相互碰撞，并且当发生这种碰撞时，参与者会知道他们碰撞到了哪种其他类型的物体。

要在不使用反射（或您所说的 RTTI，尽管它是 C++ 术语）的情况下实现此目的，使用访问者模式是一个很好的方法。您做错了什么，在这种情况下，两个对象都将充当接受者和访问者，具体取决于哪个对象与哪个对象发生碰撞。我们碰撞的对象将成为接受者（“接受碰撞对象”），碰撞另一个对象成为访问者（“访问/碰撞” 。

当碰撞物体是另一个物体时（移动的小行星碰撞到宇宙飞船与移动的宇宙飞船碰撞到静止的小行星），接收者-访问者角色可能会颠倒 在这个例子中，您可以看到，一个对象可以根据情况充当接受者或访问者，这必须反映在类层次结构中，因此两个对象都必须实现 ICollidable 和 IVisitor 接口，

我重写了您发布的代码 。 ，因此 Asteroid 和 Spaceship 类都实现了这两个接口，不再需要额外的访问者类，因为我们的对象本身就成为了访问者：

interface ICollidable
{
    void Accept(IVisitor other);
}

interface IVisitor
{
    void VisitAsteroid(Asteroid a);
    void VisitSpaceship(Spaceship s);
}

class Asteroid : ICollidable, IVisitor
{
    public void Accept(IVisitor other)
    {
        Console.Write("[Asteroid] ");
        other.VisitAsteroid(this);
    }

    public void VisitAsteroid(Asteroid a)
    {
        Console.WriteLine("Collided with asteroid");
    }

    public void VisitSpaceship(Spaceship s)
    {
        Console.WriteLine("Collided with asteroid");
    }
}

class Spaceship : ICollidable, IVisitor
{
    public void Accept(IVisitor other)
    {
        Console.Write("[Spaceship] ");
        other.VisitSpaceship(this);
    }

    public void VisitAsteroid(Asteroid a)
    {
        Console.WriteLine("Collided with spaceship");
    }

    public void VisitSpaceship(Spaceship s)
    {
        Console.WriteLine("Collided with spaceship");
    }
}


class Main
{
    public static void Main(string[] args)
    {
        Asteroid a1 = new Asteroid();
        Asteroid a2 = new Asteroid();
        Spaceship s1 = new Spaceship();
        Spaceship s2 = new Spaceship();

        s1.Accept(a1);
        s1.Accept(as);
        a1.Accept(s1);
        a2.Accept(a2);
    }
}

如果您运行该程序，您将在控制台中得到以下输出：

[Spaceship] Collided with asteroid
[Spaceship] Collided with spaceship
[Asteroid] Collided with spaceship
[Asteroid] Collided with asteroid

我希望它已经说清楚了。为您介绍如何使用此类场景的访客模式。

Answer 2

您不妨看看中介者模式。

根据维基百科页面，

使用中介者模式，对象之间的通信是用中介者对象封装的。对象之间不再直接通信，而是通过中介者进行通信。这减少了通信对象之间的依赖关系，从而降低了耦合度。

具体来说，在您的情况下，Mediator 将是一个类，所有 Collidable 都将注册到该类，并监视它们的冲突。当发生碰撞时，Mediator 将对两个碰撞对象调用 HandleCollision(Collidable other) 方法。

这样做的另一个优点是您不受任何具体实现的约束；您的碰撞机制取决于 Collidable 抽象。明天您可能会添加另一个类，只需实现 Collidable 接口，它就可以适应此机制，而无需更改其他任何内容。