Mapping two object types in C++ - c++

Question

I'm creating a small simulation framework in C++. I want to separate the pure simulation-related stuff from the displaying. So I have classes like:
class Pointer : public SimulationObject {};
class Particle : public SimulationObject {};
class LearningObserver : public SimulationObject {};
which all are derived from SimulationObject, but only some(!) have a visual representation:
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;
};
Now whenever a new SimulationObject is added to my Simulation (at runtime) I want to check, if there is a class that renders it. If so, I want to create an instance of it. My first idea was to use polymorphy:
class AbstractRenderFactory {
virtual Renderable * provideRenderable(SimulationObject * so) const = 0;
};
class ConcreteRenderFactory {
void PointerRenderable * provideRenderable(Pointer * pointer) {
return new PointerRenderable();
}
// further provideRenderable's
};
However using derived types when overridding methods obviously doesn't work (the base-method gets called). Also this is problematic since the function would only be partially defined.
Another idea was to provide an actual mapping of types:
std::map<std::type_index, std::type_index> renderTable;
but I can't get instances by just using the type_info. Do you have an idea?
Update: I tried using the visitor pattern, however I ran into similar problems. My visitor classes look like this:
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();
}
};
Plus the new base class for my Simulation parts.
class SimulationObject {
public:
Renderable * accept(RenderVisitor * renderer) {
return renderer->visit(this);
}
};
The visit-method of MyRenderVisitor obviously isn't recognized as an override of the base-class, but I was hoping that with the this pointing to the actual (derived) type, the right method (that of MyRenderVisitor) would be called.
My test-scenario looks like this:
RenderVisitor * rv = new MyRenderVisitor();
SimulationObject * pointer = new Pointer();
Renderable * renderable = pointer->accept(rv);
renderable->render();
// renderable = 0 -> seg-fault
Or is just my implementation wrong?

Answer 1

Yes, it seems you need double-dispatch technique, it can be implemented by applying the Visitor pattern.
The code to illustrate the idea:
Interface part:
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;
}
Concrete part:
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;
}
}
The ConcreteRenderableVisitor class implements logic for each leaf of SimulationObject class hierarchy.
Client code:
ConcreteRenderableVisitor visitor;
Particle particle;
particle.Accept(&visitor); // Render a particle by the visitor.
Client code 2 (more abstract example to proof the technique):
RenderableVisitor* visitor = new ConcreteRenderableVisitor;
SimulationObject* object = new Particle;
object->Accept(visitor);