Le pointeur sur fonction hors-classe n'est pas une solution très esthétique d'un point de vue C++.
De plus la fonction en question ne peut pas accéder aux membres de la classe donc l'intérêt est un peu limité.
Cela répond a certains besoins c'est clair, auquels la méthode ci-dessous ne peut pas répondre.
Mais je pense que ca vaut le coup de citer la notion de fonction virtuelle et de classe dérivée comme je l'ai utilisé dans ma lib de timer soft : http://arduino.cc/forum/index.php/topic,101814.0.html
Le besoin étant généralement d'avoir des objets qui partagent un comportement commun mais dont une fonction est différente tout en pouvant les manipuler comme des objets identiques via une classe de base.
On crée une classe de base avec des fonctions et des variables qui seront communes à toutes les différentes versions :
class Base
{
public:
Base() { variablecommune = 0; };
~Base();
int FonctionCommune( int param ) { variablecommune += param; return variablecommune; }
virtual int FonctionSpeciale( int param ) = 0; // Fonction virtuelle pure
};
Une fonction virtuelle pure ne peut pas être instanciée (on ne peut pas créer d'objet de ce type) mais on peut manipuler sous la forme de Base des objets d'une classe dérivée.
Ensuite on crée des classes dérivées qui vont avoir des variables et des comportements adaptés :
class Derivee1 : public Base
{
public:
Derivee1() : Base() { variable1 = 1; }
~Derivee1();
virtual int FonctionSpeciale( int param ) { variable1 = variablecommune + param; return variable1; }
int variable1;
}
class Derivee2 : public Base
{
Derivee2() : Base() { variable2 = 2; }
~Derivee2();
virtual int FonctionSpeciale( int param ) { variable2 = variablecommune - param; return variable2; }
int variable2;
};
et créons 2 objets ;
Derivee1 Objet1();
Derivee2 Objet2();
Jusque là rien de bien spéciale. C'est de la dérivation normale.
Mais l'avantage de l'utilisation de cette méthode c'est que l'on peut ensuite manipuler les objets Objet1 et Objet2 par exemple via des pointeurs ou des références sur un objet de type Base.
int Test( Base &objet, int param )
{
return objet.FonctionSpeciale( param );
}
Ailleurs()
{
Test( Objet1 );
Test( Objet2 );
}
Dans le code ci-dessus, la bonne FonctionSpeciale() sera appellé pour Objet1 ou Objet2 bien qu'ils soient manipulés dans Test() comme un objet de type Base.
Si les FonctionsSpeciale() n'étaient pas virtuelles, c'est la version Base::FonctionSpeciale() qui serait appellée.