Définir la fonction d'une instance de classe après qu'elle a déjà été définie

Question

J'essaie de donner des fonctions d'événement de classe telles que .onShow() et .onHide(), donc lorsque l'objet est affiché, la fonction .onShow() s'exécute . Comment puis-je permettre à la fonction d'être modifiée comme suit:

MyClass myInst = MyClass(); 
myInst.onShow = OnShowFunction; 

Est-il possible de le permettre?

Answer 1

Voici comment vous le faites (et Impress/horrifier vos vaches-es travailleurs en même temps):

#include <iostream> 

class MyClass 
    { 
public: 
    void (MyClass::*OnShow)() ; 
    void OnShowFunction() ; 
    } ; 

int main (int argc, char** argv) 
    { 
    MyClass C ; 
    C.OnShow = MyClass::OnShowFunction ; 
    (C.*C.OnShow)() ; 
    } 

void MyClass::OnShowFunction() 
    { 
    std::cout << "void MyClass::OnShowFunction()\n" ; 
    } 

Answer 2

Oui, c'est possible.

Vous devez utiliser un pointeur de fonction ou un encapsuleur qui encapsule des pointeurs de fonction et d'autres objets appelables, tels que function, que vous pouvez trouver sous différentes formes en C++ 0x, C++ TR1 et Boost. Selon la façon dont vous utilisez les rappels, une bibliothèque de signaux comme Boost.Signals peut être plus élégante.

Answer 3

Vous pouvez utiliser des pointeurs de fonction ou std::function (également dans BOOST) pour y parvenir. Cependant, il semblerait que vous essayiez d'adopter un style de programmation javascript ou langage de script en C++ - je vous en avertis, vous devriez changer votre style de programmation en fonction de la façon dont il s'adapte à la langue. Une alternative typique en C++ est d'avoir onShow une méthode virtuelle qui peut être surchargée par des dérivées.

Answer 4

Vous ne voulez probablement pas changer dynamiquement la fonction au moment de l'exécution, Si vous le faites alors l'une des autres réponses vous montrera comment utiliser les foncteurs. Mais pour moi, il semble que vous vouliez que différents objets aient des fonctionnalités différentes basées sur certaines propriétés de l'objet.

C'est ce que la fonction virtuelle sont pour:

Vous définissez l'action dans la classe de base. Ensuite, dans une classe dérivée, vous donnez l'implémentation réelle en fonction de la façon dont l'objet est censé agir.

class MyClass 
{ 
    public: 
     virtual void onShow() = 0; 
}; 

class Window: public MyClass 
{ 
    public: 
     virtual void onShow() { /* Draw Window */ } 
}; 

void aboutToShowObject(MyClass& obj) 
{ 
    obj.onShow(); 
} 

Answer 5

Vous pouvez utiliser std :: fonction qui est une classe wrapper qui vous permettra d'affecter foncteurs ainsi que des fonctions C de manière sûre.
Cependant, l'utilisation d'un foncteur Hiérarchie est une solution très simple. Ensuite, comme d'habitude, des fonctionnalités spécifiques d'onShow doivent être utilisées par le biais de membres de fonction virtuelle.

Answer 6

Si vous souhaitez modifier dynamiquement le pointeur de la fonction lors de l'exécution, vous pouvez conserver le pointeur de fonction en tant que membre et utiliser une méthode par défaut appelée OnShow() qui appelle le pointeur de fonction:

#include <iostream> 
using namespace std; 

void OnShow() { 
cout << "Showing!" << endl; 
} 

typedef void(*EventProc)(); 

class Widget { 
private: 
EventProc m_ep; 
public: 
Widget() : m_ep(0) {} 
void SetOnShow(EventProc ep) {m_ep = ep;} 
void OnShow() {(*m_ep)();} 
}; 

int main() { 
Widget w; 
w.SetOnShow(::OnShow); 
w.OnShow(); 
return 0; 
}