A quoi servent les pointeurs de fonctions et comment les utiliser?

Je comprends que je peux utiliser des pointeurs de fonctions.

Quelqu'un peut m'expliquer pourquoi les utiliser, et comment? Petit exemple de code serait très utile pour moi.

source d'informationauteur zlack

  1. 22

    Un cas simple, c'est comme ceci: Vous avez un tableau des opérations (fonctions) selon une logique d'entreprise. Vous disposez d'une fonction de hachage qui réduit un problème de saisie de l'un de l'entreprise des fonctions de logic. Un code propre aurait un tableau de pointeurs de fonction, et votre programme va en déduire un indice de ce tableau à partir de l'entrée et de l'appeler.

    Voici un exemple de code:

    typedef void (*fn)(void) FNTYPE;
FNTYPE fn_arr[5];

fn_arr[0] = fun1; //fun1 is previously defined
fn_arr[1] = fun2;
...

void callMyFun(string inp) {
    int idx = decideWhichFun(inp); //returns an int between 0 and 4
    fn_arr[idx]();
}

    Mais bien sûr, des rappels sont l'utilisation la plus courante. Exemple de code ci-dessous:

    void doLengthyOperation(string inp, void (*callback)(string status)) {
  //do the lengthy task
  callback("finished");
}

void fnAfterLengthyTask(string status) {
    cout << status << endl;
}

int main() {
    doLengthyOperation(someinput, fnAfterLengthyTask);
}
  2. 13

    Un très commun de cas d'utilisation est une fonction de rappel. Par exemple, si vous chargez quelque chose à partir d'une base que vous pouvez mettre en œuvre votre fonction de chargement de sorte que les rapports sur les progrès vers une fonction de rappel. Cela peut être fait avec des pointeurs de fonction.

  3. 5

    Rappels. Je fais un appel asynchrone à un morceau de code et il veut laissez-moi savoir quand il se termine, je peux envoyer un pointeur de fonction à appeler une fois que c'est fait.

  4. 3

    Je suis surpris que personne n'a mentionné "les machines d'état". Pointeurs de fonction sont un moyen très courant de mettre en œuvre des machines d'état pour des tâches telles que l'analyse. Voir par exemple: lien.

  5. 3

    Vous utilisez un pointeur de fonction lorsque vous avez besoin de donner une méthode de rappel. L'un des exemple classique est d'enregistrer les gestionnaires de signaux - la fonction qui sera appelée lorsque votre programme est SIGTERM (Ctrl-C)

    Voici un autre exemple:

    //The four arithmetic operations ... one of these functions is selected
//at runtime with a switch or a function pointer
float Plus    (float a, float b) { return a+b; }
float Minus   (float a, float b) { return a-b; }
float Multiply(float a, float b) { return a*b; }
float Divide  (float a, float b) { return a/b; }
//Solution with a switch-statement - <opCode> specifies which operation to execute
void Switch(float a, float b, char opCode)
{
float result;
//execute operation
switch(opCode)
{
case '+' : result = Plus     (a, b); break;
case '-' : result = Minus    (a, b); break;
case '*' : result = Multiply (a, b); break;
case '/' : result = Divide   (a, b); break;
}
cout << "Switch: 2+5=" << result << endl;         //display result
}  
//Solution with a function pointer - <pt2Func> is a function pointer and points to
//a function which takes two floats and returns a float. The function pointer
//"specifies" which operation shall be executed.
void Switch_With_Function_Pointer(float a, float b, float (*pt2Func)(float, float))
{
float result = pt2Func(a, b);    //call using function pointer
cout << "Switch replaced by function pointer: 2-5=";  //display result
cout << result << endl;
}

    Vous pouvez en apprendre plus à propos des pointeurs de fonction ici http://www.newty.de/fpt/index.html

    Si vous êtes plus familier avec les langages orientés objet, vous pouvez penser que C est la façon de mettre en œuvre les stratégie de modèle de conception.

  6. 1

    Nous allons faire un map-comme la fonction de C.

    void apply(int *arr, size_t len, int (*func)(int))
{
for(size_t i = 0; i < len; i++)
arr[i] = func(arr[i]);
}

    De cette façon, nous pouvons transformer une fonction qui travaille sur des entiers de travailler sur des tableaux de nombres entiers. Nous pourrions également faire une version similaire:

    void apply_enumerated(int *arr, size_t len, int (*func)(size_t, int))
{
for(size_t i = 0; i < len; i++)
arr[i] = func(i, arr[i]);
}

    Cela fait la même chose, mais permet à notre fonction pour savoir quel élément, c'est sur. On peut l'utiliser, par exemple:

    int cube(int i) { return i * i * i }
void print_array(int *array, size_t len, char *sep)
{
if(sep == NULL) sep = ", ";
printf("%d", *array);
for(size_t i = 1; i < len; i++) printf("%s%d", sep, array[i])
}
#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
int main(void)
{
int array[5] = { 1, 2, 3, 4, 5 };
print_array(array, ARRAY_SIZE(array), NULL);
apply(array, ARRAY_SIZE(array), cube);
print_array(array, ARRAY_SIZE(array), NULL);
return 0;
}

    Que le code d'impression:

    1, 2, 3, 4, 5
1, 8, 27, 64, 125

    Pour notre énumération exemple:

    int mult(size_t i, int j) { return i * j }
//print_array and ARRAY_SIZE as before
int main(void)
{
int array[5] = { 1, 2, 3, 4, 5 };
print_array(array, ARRAY_SIZE(array), NULL);
apply_enumerated(array, ARRAY_SIZE(array), mult);
print_array(array, ARRAY_SIZE(array), NULL);
return 0;
}

    Cette affiche:

    1, 2, 3, 4, 5
0, 2, 6, 12, 20

    Comme un monde plus réel exemple, une chaîne de la bibliothèque pourrait avoir une fonction qui applique une fonction qui fonctionne sur les caractères unique pour tous les caractères dans la chaîne. Un exemple de telles fonctions sont la norme-bibliothèque toupper() et tolower() fonctions dans ctype.h - nous pourrions utiliser ce string_apply() d'une fonction pour faire un string_toupper() fonction facilement.

  7. 1

    Un très bon et facile à comprendre tutoriel:
    http://www.newty.de/fpt/index.html

    Espère que cette aide.

  8. 0

    Une autre utilisation pour les pointeurs est une itération de listes ou de tableaux.

  9. 0

    Pour le code, découvrez qrdl réponse à les machines d'état tutoriels.

    J'ai utilisé une variante de la méthode à mettre en œuvre un menu pour un écran LCD que j'ai sur un conseil d'administration. Très très utile, rend le codage beaucoup plus propre et plus facile à lire. À l'aide de pointeurs de fonction permet d'étendre le nombre, les noms et l'ordre des menus très facile, et cache tous les détails de l'échelon supérieur, l'appel de la fonction qui voit juste " hey, j'ai écrit à l'écran LCD.