C++: ¿funciones virtuales que necesitan llamar al mismo código?

Question

Tengo una clase base y clases que derivan de ella. La clase base Controllable actúa como una interfaz para un bucle de entrada, y otras clases derivan de ella para obtener un lugar en ese bucle para obtener eventos como si se presionara una tecla.

class Controllable{ 
public: 
    virtual void setActive(bool state) { m_active = state; } 
    virtual void input(Event & e) =0; 
private: 
    bool m_active; 
}; 

class Button : public Controllable{ 
public: 
    void setActive(bool state){ /*do extra work*/ m_active = state; } 
    void input(Event & e) override; 
}; 

Desde los Button clase aborda los acontecimientos desde una cola de eventos, poniéndolo al inactivo (que lo lleva fuera del circuito de entrada) puede provocar que se pierda eventos importantes como una clave siendo sin prensar, por lo que necesita adicional código para ponerlo en un estado amistoso inactivo si alguna vez vuelve a activarse más tarde.

Mi pregunta, ¿cuál es la mejor manera de asegurar que setActive siempre tiene el efecto deseado de cambiar m_active al estado correcto, mientras que al mismo tiempo, que no requiere que las clases derivadas para definir a menos que necesitan para fijar adicional código necesario?

Answer 1

Mantenga el setActive método no virtual y luego definir un protected método separado activeChanged que las clases hijas pueden anular

class Controllable{ 
public: 
    void setActive(bool state) { m_active = state; activeChanged(state); } 
    virtual void input(Event & e) = 0; 
protected: 
    virtual void activeChanged(bool newState) {} 
private: 
    bool m_active; 
} 

class Button : public Controllable{ 
protected: 
    void activeChanged(bool newState){ /*do extra work*/ } 
public: 
    void input(Event & e); 
}; 

Con este enfoque desea mantener el externo pública interfaz separado del interna protegida interfaz destinada a clases de niños.

Answer 2

¿Qué hay de hacer que setActive() no sea virtual pero en su lugar agregue un segundo miembro virtual (por ejemplo, onSetActive()) llamado por setActive()?

Answer 3

Básicamente su caso es por encargo para Template method design pattern.

Answer 4

Una forma de hacer esto es definir "pre" y "post métodos virtuales":

class Controllable{ 
public: 
    void setActive(bool state) { 
     preSetActive(m_active, state); 
     m_active = state; 
     postSetActive(m_active); 
    }; 
    virtual void input(Event & e) =0; 
protected: 
    virtual void preSetActive(bool oldState, bool newState) {} 
    virtual void postSetActive(bool newState) {} 
private: 
    bool m_active; 
} 

en cuenta que el método es setActive()no virtual en esta técnica.

Answer 5

Mis 2 centavos: dividir su comportamiento entre 2 tareas:

virtual doActive(){}; //doNothing 
void setActive (bool state) { 
    m_active = state; 
    doActive(); 
}