C++ wie Methode in abgeleiteten Klasse von Basisklasse aufrufen

Question

Was ich tun möchte, ist für Execute() zu laufen und schließt es ruft die Base::Done() dann ruft die Derived::Done(). Ich mache das, weil Base Klasse Execute etwas tun wird und wenn es fertig ist, rufen Sie die Derived::Done(). Ich hoffe ich erkläre es richtig. Ein bisschen wie ein Zuhörer, der aufgerufen wird, wenn eine Aufgabe abgeschlossen ist. Ich bin irgendwie fest, wie die Base Klasse die Derived Klasse aufrufen wird.

class Base 
{ 
    virtual void Done(int code){}; 
    void Execute(); 
} 

void Base::Execute() 
{ 
} 


class Derived : Base 
{ 
    void Done(int code); 
    void Run(); 
} 

Derived::Done(int code) 
{ 
} 

void Derived::Run() 
{ 
    Execute(); 
} 

Answer 1

Sie können eine Vorlage Methode verwenden:

class Base 
{ 
public: 
    void Execute() 
    { 
    BaseDone(42); 
    DoDone(42); 
    } 
private: 
    void BaseDone(int code){}; 
    virtual void DoDone(int) = 0; 
}; 

class Derived : Base 
{ 
public: 
    void Run() { Execute(); } 
private: 
    void DoDone(int code) { .... } 
}; 

Hier Base steuert, wie seine eigene und abgeleitete Methoden in Execute() verwendet werden, und die abgeleiteten Typen nur eine Komponente dieser Umsetzung zu implementieren über eine private virtuelle Methode DoDone().

Answer 2

Die Basisklasse Methode kann ganz einfach die abgeleitete Methode aufrufen:

void Base::Execute() 
{ 
    Done(42); 
} 

Um die Basisklasse Done() vor der abgeleiteten Klasse aufgerufen, können Sie es entweder als erste Anweisung in der abgeleiteten Klasse aufrufen Methode oder verwenden Sie das nicht-virtuelle Idiom.

Hier ist ein Beispiel für den Aufruf am Anfang der abgeleiteten Klassenmethode. Dies beruht auf der abgeleiteten Klasse, um es richtig zu machen.

void Derived::Done(int code) 
{ 
    Base::Done(code); 
} 

Hier ist ein Beispiel für das nicht-virtuelle Idiom mit:

class Base 
{ 
    void Done(int code){ 
     // Do whatever 
     DoneImpl(); // Do derived work. 
    } 
    virtual void DoneImpl() { }; 
    ... 
}; 

class Derived { 
    virtual void DoneImpl() { 
     // Do derived class work. 
    }; 
    ... 
};