Pointeurs sur méthode

Voir version :

Pas de dépendances

Télécharger :

#include <iostream>

class Test
{
public:
    void fonc1() {std::cout << "fonc1" << std::endl;}
    void fonc2() {std::cout << "fonc2" << std::endl;}
};



int main()
{
    Test a;
    void (Test::*p)();

    p = &Test::fonc1;
    (a.*p)();

    p = &Test::fonc2;
    (a.*p)();

    return 0;
}

	Ah les pointeurs de méthode et leur syntaxe exotique...

	Dans la classe Test, je fais deux fontions ayant la même signature : fonc1 et fonc2
	Dedans, juste un cout qui dit par ou on passe...

	Dans le main, je déclare un pointeur p sur une méthode de Test, qui retourne void et ne prend pas d'arguments.
	void (Test::*p)();

	Puis je pose mon pointeur sur la méthode fonc1.
	Notez que jusque la, je n'ai pas considéré du tout l'instance : le pointeur est posé sur la classe, et non une instance.

	C'ets quand je décide d'appeler le pointeur, donc lancer la méthode, que cette fois ci je lui parle d'une instance a.
	La syntaxe est la suivante :

	(a.*p)();

	Si je voulais mettre des paramètres, je les mettrais dans les parenthèses qui suivent, 
	si je voulais récupérer une valeur de retour, je ferais plouf = (a.*p)();

	A la fin du programme, je change le pointeur de place, et je relance depuis l'instance a.

	Cet exemple permet juste de montrer la syntaxe exotique de la chose.
	Personnellement, il m'évitera de chercher à chaque fois sur le net.