Fuerza llamar a la clase base función virtual

Question

Tengo algunos eventos como este

class Granpa // this would not be changed, as its in a dll and not written by me 
{ 
public: 

    virtual void onLoad(){} 

} 

class Father :public Granpa // my modification on Granpa 
{ 
public: 

    virtual void onLoad() 
    { 
     // do important stuff 
    } 

} 

class Child :public Father// client will derive Father 
{ 

    virtual void onLoad() 
    { 
     // Father::onLoad(); // i'm trying do this without client explicitly writing the call 

     // clients code 
    } 
} 

¿Hay una manera de forzar onLoad llamando sin escribir Padre :: onLoad()?

soluciones hacker son bienvenidos :)

Answer 1

Si he entendido bien, usted lo desea de manera que cada vez que la función se llama a overriden, la implementación de la clase base debe siempre llamará en primer lugar. En ese caso, puede investigar el template pattern. Algo como:

class Base 
{ 
public: 
    void foo() { 
     baseStuff(); 
     derivedStuff(); 
    } 

protected: 
    virtual void derivedStuff() = 0; 
private: 
    void baseStuff() { ... } 
}; 

class Derived : public Base { 
protected: 
    virtual void derivedStuff() { 
     // This will always get called after baseStuff() 
     ... 
    } 
}; 

Answer 2

Como se sugirió anteriormente, pero se aplica a su caso.

class Father :public Granpa // my modification on Granpa 
{ 

public: 

    virtual void onLoad() 
    { 
     // do important stuff 
     onLoadHandler(); 
    } 
    virtual void onLoadHandler()=0; 
} 

class Child :public Father// client will derive Father 
{ 

    virtual void onLoadHandler() 
    { 

     // clients code 
    } 
} 

Sin embargo, nada puede evitar Niño para anular onLoad ya que C++ no tiene ninguna palabra clave final y Granpa onLoad es en sí virtual.

Answer 3

Bueno, no hay una forma ampliamente conocida y reconocida de hacer esto. Si hubiera existido, las bibliotecas de GUI que usan eventos y señales probablemente lo habrían implementado. Sin embargo, hay otras soluciones a su problema.

Puede implementar una conexión de señal de evento, usando boost.Signals, sigslot o algo por su cuenta. Como GTK + hace:

g_signal_connect(my_wdg, "expose-event", G_CALLBACK(my_func), NULL); 

gboolean my_func(...) 
{ 
    // do stuff 
    return FALSE; /* this tells the event handler to also call the base class's slot */ 
} 

En una forma menos C-céntrico, esto podría ser implementado a lo largo de estas líneas:

/* In Granpa */ 
/* typedef a functor as 'DerivedEventHandler' or use a boost::function */ 
std::vector<DerivedEventHandler> handlers; 

void connect(DerivedEventHandler event) { handlers.push_back(event); } 

/* in loop */ 
while (! iter = handlers.end()) /* call event */ 

/* In constructor of Father */ 
this->connect(this->OnLoad); 

/* In constructor of Child */ 
this->connect(this->OnLoad); 

/* and so on... in all derived classes */ 

Answer 4

Si el objeto en cuestión es pequeño y barato para copiar, simplemente llame a la base class 'copy constructor, es decir, BaseClass (* derived_class_object) .method()