1

我正在用 C++ 创建一个小型模拟框架。我想将纯模拟相关的东西从显示中分离出来。所以我有这样的课程：

class Pointer : public SimulationObject {};
class Particle : public SimulationObject {};
class LearningObserver : public SimulationObject {};

它们都是从 SimulationObject 派生的，但只有一些（！）具有视觉表示：

class Renderable {
public:
    virtual void render() const = 0;
//may also include reference to assosciated SimulationObject
}
class PointerRenderable : public Renderable {
    void render() const { std::cout << "Render a pointer" << std::endl;
};
class ParticleRenderable : public Renderable {
    void render() const { std::cout << "Render a particle" << std::endl;
};

现在，每当将新的 SimulationObject 添加到我的 Simulation（在运行时）中时，我都想检查是否有一个类可以渲染它。如果是这样，我想创建它的一个实例。我的第一个想法是使用多态性：

class AbstractRenderFactory {
   virtual Renderable * provideRenderable(SimulationObject * so) const = 0;
};

class ConcreteRenderFactory {
   void PointerRenderable * provideRenderable(Pointer * pointer) {
       return new PointerRenderable();
   }
   // further provideRenderable's
};

但是，当覆盖方法显然不起作用时使用派生类型（基方法被调用）。这也是有问题的，因为该功能只会被部分定义。

另一个想法是提供类型的实际映射：

std::map<std::type_index, std::type_index> renderTable;

但我无法仅使用 type_info 获取实例。你有想法吗？

更新：我尝试使用访问者模式，但是我遇到了类似的问题。我的访问者类如下所示：

class RenderVisitor {
public:
    virtual Renderable * visit(SimulationObject * so) {
         // I would like to have this method abstract, but I could live with this
         return 0;
    }
};

class MyRenderVisitor : public RenderVisitor {
public:
    Renderable * visit(Pointer * pointer) const {
        return new PointerRenderable();
    }
};

加上我的模拟部件的新基类。

class SimulationObject {
public:
    Renderable * accept(RenderVisitor * renderer) {
        return renderer->visit(this);
    }
};

MyRenderVisitor 的访问方法显然不被识别为基类的覆盖，但我希望通过this指向实际（派生）类型，调用正确的方法（MyRenderVisitor 的方法）。

我的测试场景如下所示：

RenderVisitor * rv = new MyRenderVisitor();
SimulationObject * pointer = new Pointer();

Renderable * renderable = pointer->accept(rv);
renderable->render();
// renderable = 0 -> seg-fault

或者只是我的实施错误？

4

1 回答 1

1

是的，看来您需要双重调度技术，可以通过应用访问者模式来实现。说明这个想法的代码：

接口部分：

class SimulationObject {
public:
    virtual void Accept(RenderableVisitor* visitor) const = 0;
    ...
};

class RenderableVisitor {
public:
    virtual void Visit(Pointer* pointer) const = 0;
    virtual void Visit(Particle* particle) const = 0;
    virtual void Visit(LearningObserver* learning_observer) const = 0;
}

混凝土部分：

class Pointer : public SimulationObject {
public:
    virtual void Accept(RenderableVisitor* visitor) const
    {
        visitor->Visit(this);
    }
};

class Particle : public SimulationObject {
public:
    virtual void Accept(RenderableVisitor* visitor) const
    {
        visitor->Visit(this);
    }
};

class LearningObserver : public SimulationObject {
public:
    virtual void Accept(RenderableVisitor* visitor) const
    {
        visitor->Visit(this);
    }
};

class ConcreteRenderableVisitor : public RenderableVisitor {
public:
    virtual void Visit(Pointer* pointer) const
    {
        std::cout << "Render a pointer" << std::endl;
    }

    virtual void Visit(Particle* particle) const
    {
        std::cout << "Render a particle" << std::endl;
    }

    virtual void Visit(LearningObserver* learning_observer) const
    {
        std::cout << "Render a learning observer" << std::endl;
    }
}

该类为类层次结构ConcreteRenderableVisitor的每个叶子实现逻辑。SimulationObject

客户端代码：

ConcreteRenderableVisitor visitor;
Particle particle;
particle.Accept(&visitor); // Render a particle by the visitor.

客户端代码 2（更抽象的示例来证明该技术）：

RenderableVisitor* visitor = new ConcreteRenderableVisitor;
SimulationObject* object = new Particle;
object->Accept(visitor);
于 2013-01-27T09:03:26.070 回答