Comment appeler la fonction en utilisant le pointeur de fonction?

Supposons que j’ai ces trois fonctions:

bool A(); bool B(); bool C(); 

Comment appeler une de ces fonctions de manière conditionnelle à l’aide d’un pointeur de fonction et comment déclarer le pointeur de fonction?

Vous pouvez effectuer les opérations suivantes: Supposons que vous ayez les fonctions A, B et C suivantes:

 bool A() { ..... } bool B() { ..... } bool C() { ..... } 

Maintenant, à une autre fonction, dites à main:

 int main() { bool (*choice) (); // now if there is if-else statement for making "choice" to // point at a particular function then proceed as following if ( x == 1 ) choice = A; else if ( x == 2 ) choice = B; else choice = C; if(choice()) printf("Success\n"); else printf("Failure\n"); ......... ......... } 

Rappelez-vous qu’il s’agit d’un exemple de pointeur de fonction. il existe plusieurs autres méthodes pour lesquelles vous devez apprendre le pointeur de fonction clairement.

Déclarez votre pointeur de fonction comme ceci:

 bool (*f)(); f = A; f(); 

Initialement, définissez un tableau de pointeurs de fonction qui prend un vide et renvoie un vide. en supposant que votre fonction prend un vide et retourne un vide.

 typedef void (*func_ptr)(void); 

Maintenant, vous pouvez l’utiliser pour créer des variables de pointeur de fonction de ces fonctions. comme ci-dessous:

 func_ptr array_of_fun_ptr[3]; 

stockez maintenant l’adresse de vos fonctions dans les trois variables.

 array_of_fun_ptr[0]= &A; array_of_fun_ptr[1]= &B; array_of_fun_ptr[2]= &C; 

maintenant vous pouvez appeler ces fonctions en utilisant les pointeurs de fonction comme ci-dessous:

 some_a=(*(array_of_fun_ptr[0]))(); some_b=(*(array_of_fun_ptr[1]))(); some_c=(*(array_of_fun_ptr[2]))(); 

Je pense que votre question a déjà reçu une réponse plus que suffisante, mais il pourrait être utile de souligner explicitement que, étant donné un pointeur de fonction

 void (*pf)(int foo, int bar); 

les deux appels

 pf(1, 0); (*pf)(1, 0); 

sont exactement équivalents à tous égards par définition. Le choix de l’utilisation dépend de vous, bien que ce soit une bonne idée d’être cohérent. Pendant longtemps, j’ai préféré (*pf)(1, 0) car il me semblait que cela reflétait mieux le type de pf , mais je suis passé à pf(1, 0) au cours des dernières années.

Vous pouvez déclarer le pointeur de fonction comme suit:

 bool (funptr*)(); 

Ce qui dit que nous déclarons un pointeur de fonction sur une fonction qui ne prend rien et retourne un bool.

Prochaine affectation:

 funptr = A; 

Pour appeler la fonction en utilisant le pointeur de fonction:

 funptr(); 
 bool (*FuncPtr)() FuncPtr = A; FuncPtr(); 

Si vous souhaitez appeler l’une de ces fonctions de manière conditionnelle, vous devez envisager d’utiliser un tableau de pointeurs de fonction . Dans ce cas, vous avez 3 éléments pointant vers A, B et C et vous en appelez un en fonction de l’index du tableau, tel que funcArray0 pour A.

 bool (*fptr)(); int main(void) { ... ... printf("Enter your choice"); scanf("%d",&a); switch(a) { case 0: fptr = A; break; case 1: fptr = B; break; case 2: fptr = C; break; case 3: break; } (*fptr)(); return 0; } 

votre choix est stocké dans un; Ensuite, les fonctions sont atsortingbuées dans le pointeur de fonction. Enfin, selon votre choix, la même fonction est appelée pour renvoyer le résultat souhaité.

Notez que lorsque vous dites:

 bool (*a)(); 

vous déclarez a type “pointeur sur une fonction renvoyant bool et prenant un nombre non spécifié de parameters”. En supposant que bool soit défini (peut-être que vous utilisez C99 et que vous avez inclus stdbool.h , ou que cela peut être une typedef), cela peut être ou ne pas être ce que vous voulez.

Le problème ici est qu’il n’ya aucun moyen pour le compilateur de vérifier si a est affecté à une valeur correcte. Le même problème existe avec vos déclarations de fonction. A() , B() et C() sont tous déclarés en tant que fonctions “renvoyant bool et prenant un nombre indéterminé de parameters”.

Pour voir le genre de problèmes que cela peut avoir, écrivons un programme:

 #include  int test_zero(void) { return 42; } static int test_one(char *data) { return printf("%s\n", data); } int main(void) { /* a is of type "pointer to function returning int and taking unspecified number of parameters */ int (*a)(); /* b is of type "pointer to function returning int and taking no parameters */ int (*b)(void); /* This is OK */ a = test_zero; printf("a: %d\n", a()); a = test_one; /* OK, since comstackr doesn't check the parameters */ printf("a: %d\n", a()); /* oops, wrong number of args */ /* This is OK too */ b = test_zero; printf("b: %d\n", b()); /* The comstackr now does type checking, and sees that the assignment is wrong, so it can warn us */ b = test_one; printf("b: %d\n", b()); /* Wrong again */ return 0; } 

Quand je comstack ce qui précède avec gcc, il est écrit:

warning: affectation de type de pointeur incompatible

pour la ligne b = test_one; , ce qui est bon. Il n’y a pas d’avertissement pour l’affectation correspondante à a .

Donc, vous devriez déclarer vos fonctions comme:

 bool A(void); bool B(void); bool C(void); 

Et puis la variable pour contenir la fonction doit être déclarée comme:

 bool (*choice)(void); 

La meilleure façon de lire cela est la “ règle dans le sens horaire / spirale ”

Par David Anderson

http://c-faq.com/decl/spiral.anderson.html

Vous déclarez une variable de pointeur de fonction pour la signature donnée de vos fonctions comme suit:

 bool (* fnptr)(); 

vous pouvez lui atsortingbuer une de vos fonctions:

 fnptr = A; 

et vous pouvez l’appeler:

 bool result = fnptr(); 

Vous pouvez envisager d’utiliser typedefs pour définir un type pour chaque signature de fonction distincte dont vous avez besoin. Cela facilitera la lecture et la maintenance du code. C’est-à-dire que pour la signature de fonctions retournant bool sans arguments, cela pourrait être:

 typdef bool (* BoolFn)(); 

et ensuite vous pouvez utiliser comme ceci pour déclarer la variable de pointeur de fonction pour ce type:

 BoolFn fnptr; 

Approche légèrement différente:

 bool A() {...} bool B() {...} bool C() {...} int main(void) { /** * Declare an array of pointers to functions returning bool * and initialize with A, B, and C */ bool (*farr[])() = {A, B, C}; ... /** * Call A, B, or C based on the value of i * (assumes i is in range of array) */ if (farr[i]()) // or (*farr[i])() { ... } ... } 
 //Declare the pointer and asign it to the function bool (*pFunc)() = A; //Call the function A pFunc(); //Call function B pFunc = B; pFunc(); //Call function C pFunc = C; pFunc(); 

J’utilise habituellement typedef pour le faire, mais c’est peut-être excessif si vous n’avez pas à utiliser le pointeur de fonction trop souvent ..

 //assuming bool is available (where I come from it is an enum) typedef bool (*pmyfun_t)(); pmyfun_t pMyFun; pMyFun=A; //pMyFun=&A is actually same pMyFun(); 

Ce problème a été résolu de manière plus que satisfaisante, mais vous pouvez trouver cela utile: Didacticiels sur les pointeurs de fonction . C’est un traitement vraiment complet du sujet en cinq chapitres!

Si vous avez besoin d’aide pour des définitions complexes, comme par exemple:

 double (*(*pf)())[3][4]; 

Jetez un coup d’œil à ma règle droite-gauche ici .