¿Cómo evitar el downcast?

Question

Tengo una implementación de Patrón de estado donde cada estado maneja los eventos que obtiene de una cola de eventos. Por lo tanto, la clase base State tiene un método virtual puro void handleEvent(const Event*). Los eventos heredan la clase base Event pero cada evento contiene sus datos que pueden ser de un tipo diferente (por ejemplo, int, cadena ... o lo que sea). handleEvent tiene que determinar el tipo de tiempo de ejecución del evento recibido y luego realizar downcast para extraer datos de eventos. Los eventos se crean dinámicamente y se almacenan en una cola (por lo que upcasting tiene lugar aquí ...).

Sé que el downcasting es un signo de un mal diseño, pero es posible evitarlo en este caso? Estoy pensando en Patrón de visitante donde el estado de la clase base contendría controladores virtuales para cada evento, pero luego se tendrá que realizar un downcast en el fragmento de código que dequeue el evento de una cola y lo pasa al estado actual. (Al menos en este caso grande switch(eventID) sería solo en un lugar ...). ¿El patrón de visitante es la mejor manera (práctica recomendada) para evitar la bajada?

Aquí es el pseudo-código (estoy pasando boost::shared_ptr en este ejemplo, pero downcasting pasa de todos modos):

enum EventID 
{ 
    EVENT_1, 
    EVENT_2, 
    ... 
}; 

class Event 
{ 
    EventID id; 
public: 
    Event(EventID id):id(id){} 
    EventID id() const {return id;} 
    virtual ~Event() = 0; 
}; 

class Event1 : public Event 
{ 
    int n; 
public: 
    Event1(int n):Event(EVENT_1), n(n){} 
    int getN() const {return n;} 
}; 

class Event2 : public Event 
{ 
    std::string s; 
public: 
    Event2(std::string s):Event(EVENT_2), s(s){} 
    std::string getS() const {return s;} 
}; 

typedef boost::shared_ptr<Event> EventPtr; 

class State 
{ 
    ... 
public: 
    ... 
    virtual ~State() = 0; 
    virtual void handleEvent(const EventPtr& pEvent) = 0; 
}; 

class StateA : public State 
{ 
    ... 
public: 
    void handleEvent(const EventPtr& pEvent) 
    { 
     switch(pEvent->id()) 
     { 
     case EVENT_1:   
      int n = boost::static_pointer_cast<Event1>(pEvent)->getN(); 
      ... 
      break; 
     case EVENT_2: 
      std::string s = boost::static_pointer_cast<Event2>(pEvent)->getS(); 
      ... 
      break; 
     ... 

     } 
    } 
} 

Answer 1

El patrón típico visitante realiza ninguna abatido, gracias a una estrategia de doble expedición:

// Visitor.hpp 
class EventBar; 
class EventFoo; 

class Visitor { 
public: 
    virtual void handle(EventBar const&) = 0; 
    virtual void handle(EventFoo const&) = 0; 
}; 

// Event.hpp 
class Visitor; 

class Event { 
public: 
    virtual void accept(Visitor&) const = 0; 
}; 

Y las implementaciones:

// EventBar.hpp 
#include <Event.hpp> 

class EventBar: public Event { 
public: 
    virtual void accept(Visitor& v); 
}; 

// EventBar.cpp 
#include <EventBar.hpp> 
#include <Visitor.hpp> 

void EventBar::accept(Visitor& v) { 
    v.handle(*this); 
} 

El punto clave aquí es que en v.handle(*this) el tipo estático de *this es EventBar const&, que selecciona la sobrecarga virtual void handle(EventBar const&) = 0 correcta en Visitor.

Answer 2

La idea de los eventos es pasar objetos detallados a través de una interfaz generalizada (y agnóstica). Downcast es inevitable y parte del diseño. Malo o bueno, es discutible.

El patrón de visitante solo oculta el yeso de usted. Todavía se realiza detrás de escena, los tipos se resuelven a través de la dirección del método virtual.

Debido a que su Event ya tiene la identificación, no es completamente independiente del tipo, por lo que la fundición es perfectamente segura. Aquí está viendo el tipo personalmente, en el patrón de visitante está haciendo que el compilador se encargue de eso.

"Todo lo que sube debe bajar".