Comment faire des pointeurs de fonction en C travail?

Pointeurs de fonction en C

Commençons avec une fonction de base qui nous sera pointant vers:

int addInt(int n, int m) {
    return n+m;
}

Première chose, nous allons définir un pointeur vers une fonction qui reçoit 2 ints et renvoie un int:

int (*functionPtr)(int,int);

Maintenant nous pouvons point à notre fonction:

functionPtr = &addInt;

Maintenant que nous avons un pointeur vers la fonction, nous allons utiliser:

int sum = (*functionPtr)(2, 3); //sum == 5

En passant le pointeur à une autre fonction est fondamentalement la même:

int add2to3(int (*functionPtr)(int, int)) {
    return (*functionPtr)(2, 3);
}

Nous pouvons utiliser des pointeurs de fonction dans les valeurs de retour ainsi (essayer de suivre, il obtient le désordre):

//this is a function called functionFactory which receives parameter n
//and returns a pointer to another function which receives two ints
//and it returns another int
int (*functionFactory(int n))(int, int) {
    printf("Got parameter %d", n);
    int (*functionPtr)(int,int) = &addInt;
    return functionPtr;
}

Mais il est beaucoup plus agréable d'utiliser un typedef:

typedef int (*myFuncDef)(int, int);
//note that the typedef name is indeed myFuncDef

myFuncDef functionFactory(int n) {
    printf("Got parameter %d", n);
    myFuncDef functionPtr = &addInt;
    return functionPtr;
}

OriginalL'auteur Yuval Adam

Le guide de licenciement: Comment l'abus des pointeurs de fonction dans GCC sur des machines x86 par la compilation de votre code à la main:

Ces littéraux de chaîne sont des octets de 32 bits x86 code machine. 0xC3 est un x86 ret enseignement.

Vous ne serait pas l'habitude d'écrire à la main, vous voulez écrire en langage d'assemblage et ensuite utiliser un assembleur comme nasm de le monter dans un plat binaire qui vous convertir en un C un littéral de chaîne.

1. Retourne la valeur courante du registre EAX

   int eax = ((int(*)())("\xc3 <- This returns the value of the EAX register"))();

2. Écrire une fonction d'échange de

   int a = 10, b = 20;
   ((void(*)(int*,int*))"\x8b\x44\x24\x04\x8b\x5c\x24\x08\x8b\x00\x8b\x1b\x31\xc3\x31\xd8\x31\xc3\x8b\x4c\x24\x04\x89\x01\x8b\x4c\x24\x08\x89\x19\xc3 <- This swaps the values of a and b")(&a,&b);

3. Écrire un compteur de boucle de 1000, en appelant une fonction à chaque fois

   ((int(*)())"\x66\x31\xc0\x8b\x5c\x24\x04\x66\x40\x50\xff\xd3\x58\x66\x3d\xe8\x03\x75\xf4\xc3")(&function); //calls function with 1->1000

4. Vous pouvez même écrire une fonction récursive qui compte pour 100

   const char* lol = "\x8b\x5c\x24\x4\x3d\xe8\x3\x0\x0\x7e\x2\x31\xc0\x83\xf8\x64\x7d\x6\x40\x53\xff\xd3\x5b\xc3\xc3 <- Recursively calls the function at address lol.";
   i = ((int(*)())(lol))(lol);

Noter que les compilateurs place littéraux de chaîne dans la .rodata section (ou .rdata sur Windows), qui est liée dans le cadre du segment de texte (avec code pour les fonctions).

Le segment de texte a Lire+Exec autorisation, afin de casting littéraux de chaîne de pointeurs de fonction fonctionne sans avoir besoin mprotect() ou VirtualProtect() appels système comme vous auriez besoin pour la mémoire allouée dynamiquement. (Ou gcc -z execstack liens du programme avec pile + segment de données + tas exécutable, comme un rapide hack.)

---

À démonter ces, vous pouvez le compiler à mettre une étiquette sur les octets, et utiliser un désassembleur.

//at global scope
const char swap[] = "\x8b\x44\x24\x04\x8b\x5c\x24\x08\x8b\x00\x8b\x1b\x31\xc3\x31\xd8\x31\xc3\x8b\x4c\x24\x04\x89\x01\x8b\x4c\x24\x08\x89\x19\xc3 <- This swaps the values of a and b";

De la compilation avec gcc -c -m32 foo.c et à démonter avec objdump -D -rwC -Mintel, nous pouvons obtenir de l'assemblée, et que ce code viole les ABI casser les EBX (un appel préservé registre) et est généralement inefficace.

00000000 <swap>:
   0:   8b 44 24 04             mov    eax,DWORD PTR [esp+0x4]   # load int *a arg from the stack
   4:   8b 5c 24 08             mov    ebx,DWORD PTR [esp+0x8]   # ebx = b
   8:   8b 00                   mov    eax,DWORD PTR [eax]       # dereference: eax = *a
   a:   8b 1b                   mov    ebx,DWORD PTR [ebx]
   c:   31 c3                   xor    ebx,eax                # pointless xor-swap
   e:   31 d8                   xor    eax,ebx                # instead of just storing with opposite registers
  10:   31 c3                   xor    ebx,eax
  12:   8b 4c 24 04             mov    ecx,DWORD PTR [esp+0x4]  # reload a from the stack
  16:   89 01                   mov    DWORD PTR [ecx],eax     # store to *a
  18:   8b 4c 24 08             mov    ecx,DWORD PTR [esp+0x8]
  1c:   89 19                   mov    DWORD PTR [ecx],ebx
  1e:   c3                      ret    

  not shown: the later bytes are ASCII text documentation
  they're not executed by the CPU because the ret instruction sends execution back to the caller

Ce code machine sera (probablement) de travail dans le code 32 bits sur Windows, Linux, OS X, et ainsi de suite: par défaut, les conventions d'appel sur tous les Systèmes d'exploitation passer des arguments sur la pile au lieu de manière plus efficace dans les registres. Mais EBX est conservé dans toutes les conventions d'appel, afin de l'utiliser comme une égratignure registre sans sauvegarde/restauration de on peut facilement faire de l'appelant incident.

OriginalL'auteur

Pointeurs de fonction facile à déclarer une fois que vous avez la base declarators:

• id: ID: ID est un
• Pointeur: *D: D pointeur vers
• Fonction: D(<parameters>): D fonction prenant <paramètres> retour

Alors que D est une autre déclaration construit à l'aide de ces mêmes règles. En fin de compte, quelque part, elle se termine avec ID (voir ci-dessous pour un exemple), qui est le nom de la déclaration de l'entité. Nous allons essayer de construire une fonction prenant un pointeur vers une fonction prend rien et le retour de type int, et retournant un pointeur à une fonction prenant un char et le retour de type int. Avec type-defs c'est comme ça

typedef int ReturnFunction(char);
typedef int ParameterFunction(void);
ReturnFunction *f(ParameterFunction *p);

Comme vous le voyez, il est assez facile de le construire à l'aide de typedefs. Sans typedefs, il n'est pas difficile, soit avec la déclaration de règles, appliquées de manière cohérente. Comme vous le voyez j'ai raté la partie sur laquelle pointe le pointeur, et la chose la fonction retourne. C'est ce qui apparaît à l'extrême gauche de la déclaration, et n'est pas d'intérêt: Il est ajouté à la fin si l'on construit le constate déjà. Faisons-le. Mettre en place de manière cohérente, premier long - montrant la structure à l'aide de [ et ]:

function taking 
    [pointer to [function taking [void] returning [int]]] 
returning
    [pointer to [function taking [char] returning [int]]]

Comme vous le voyez, on peut décrire un type complètement en ajoutant declarators l'une après l'autre. La Construction peut se faire de deux façons. On est bottom-up, à commencer par la très bonne chose (les feuilles) et sur le même chemin jusqu'à l'identificateur. L'autre façon est de haut en bas, en commençant à l'identifiant, le travail de la manière vers le bas pour les feuilles. Je vais vous montrer deux façons.

De Bas En Haut

La Construction commence par la chose à la droite: La chose retourné, ce qui est la fonction la prise de char. Pour garder la declarators distinctes, je vais les numéroter:

D1(char);

Inséré le char paramètre directement, puisqu'il est trivial. L'ajout d'un pointeur de déclaration par le remplacement de D1 par *D2. Notez que nous avons pour envelopper les parenthèses autour de *D2. Ce qui peut être connu par la recherche de la primauté de la *-operator et la fonction d'appel de l'opérateur (). Sans notre parenthèses, le compilateur pourrait le lire comme *(D2(char p)). Mais ce ne serait pas un simple remplacement de D1 par *D2 plus, bien sûr. Les parenthèses sont toujours autorisés autour de declarators. Afin de ne pas faire quelque chose de mal si vous ajoutez trop d'entre eux, en fait.

(*D2)(char);

Type de retour est complet! Maintenant, nous allons remplacer D2 par la fonction de demande de déclaration fonction prenant <parameters> retour, qui est D3(<parameters>) laquelle nous sommes maintenant.

(*D3(<parameters>))(char)

Notez que les parenthèses sont nécessaires, car nous voulez D3 à une fonction de demande de déclaration et non pas un pointeur déclaration de ce temps. La grande, la seule chose qui reste est les paramètres pour cela. Le paramètre est en fait exactement la même chose que nous avons fait le type de retour, juste avec char remplacé par void. Donc je vais le copier:

(*D3(   (*ID1)(void)))(char)

J'ai remplacé D2 par ID1, puisque nous en avons terminé avec ce paramètre (c'est déjà un pointeur vers une fonction - pas besoin d'une autre demande de déclaration). ID1 sera le nom du paramètre. Maintenant, j'ai dit ci-dessus à la fin on ajoute le type qui tous ceux déclaration de modifier, l'une apparaissant à l'extrême gauche de chaque déclaration. Pour les fonctions, qui devient le type de retour. Pour les pointeurs le fait de taper etc... C'est intéressant lorsqu'il est écrit en bas de la type, il apparaîtra dans l'ordre inverse, à droite 🙂 de toute façon, en le substituant les rendements de la déclaration complète. Les deux fois int de cours.

int (*ID0(int (*ID1)(void)))(char)

J'ai appelé l'identificateur de la fonction ID0 dans cet exemple.

De Haut En Bas

Cela commence à l'identifiant le plus à gauche dans la description du type, de l'emballage, qui constate que nous marchons notre chemin à travers le droit. Commencez avec fonction prenant <paramètres> retour

ID0(<parameters>)

La prochaine chose dans la description (d'après "le retour") a été pointeur vers. Nous allons l'intégrer:

*ID0(<parameters>)

Puis la prochaine chose était due à la prise de <paramètres> retour. Le paramètre est un simple char, afin de nous mettre tout de suite à nouveau, car il est vraiment trivial.

(*ID0(<parameters>))(char)

Notez les parenthèses, nous avons ajouté, depuis que nous voulons plus que le * se lie d'abord, et puis la (char). Sinon, il serait de lire fonction prenant <paramètres> le retour de fonction .... Rex, fonctions retournant des fonctions qui ne sont même pas autorisés.

Maintenant nous avons juste besoin de mettre <paramètres>. Je vais vous montrer une version courte de la deriveration, car je pense que vous avez déjà maintenant avoir l'idée de comment le faire.

pointer to: *ID1
... function taking void returning: (*ID1)(void)

Vient de mettre int avant la declarators comme nous l'avons fait avec bottom-up, et nous sommes finis

int (*ID0(int (*ID1)(void)))(char)

La bonne chose

Est bottom-up ou top-down de mieux? J'ai l'habitude de bottom-up, mais certaines personnes peuvent être plus à l'aise avec de haut en bas. C'est une question de goût je pense. D'ailleurs, si vous appliquez tous les opérateurs dans cette déclaration, vous finirez toujours par un int:

int v = (*ID0(some_function_pointer))(some_char);

Qui est un bel établissement de déclarations en C: La déclaration affirme que si ces opérateurs sont utilisés dans une expression à l'aide de l'identifiant, puis il donne le type de la plus à gauche. C'est comme ça pour les tableaux de trop.

Espère que vous avez aimé ce petit tutoriel! Maintenant, nous pouvons lien vers cette quand les gens s'interroger sur l'étrange syntaxe de déclaration de fonctions. J'ai essayé de mettre un peu de C internals que possible. N'hésitez pas à modifier/corriger les choses.

OriginalL'auteur

Pointeur de fonction est généralement défini par typedef, et utilisé comme param & valeur de retour,

Réponses ci-dessus déjà expliqué beaucoup de choses, je viens de donner un exemple complet:

#include <stdio.h>

#define NUM_A 1
#define NUM_B 2

//define a function pointer type
typedef int (*two_num_operation)(int, int);

//an actual standalone function
static int sum(int a, int b) {
    return a + b;
}

//use function pointer as param,
static int sum_via_pointer(int a, int b, two_num_operation funp) {
    return (*funp)(a, b);
}

//use function pointer as return value,
static two_num_operation get_sum_fun() {
    return &sum;
}

//test - use function pointer as variable,
void test_pointer_as_variable() {
    //create a pointer to function,
    two_num_operation sum_p = &sum;
    //call function via pointer
    printf("pointer as variable:\t %d + %d = %d\n", NUM_A, NUM_B, (*sum_p)(NUM_A, NUM_B));
}

//test - use function pointer as param,
void test_pointer_as_param() {
    printf("pointer as param:\t %d + %d = %d\n", NUM_A, NUM_B, sum_via_pointer(NUM_A, NUM_B, &sum));
}

//test - use function pointer as return value,
void test_pointer_as_return_value() {
    printf("pointer as return value:\t %d + %d = %d\n", NUM_A, NUM_B, (*get_sum_fun())(NUM_A, NUM_B));
}

int main() {
    test_pointer_as_variable();
    test_pointer_as_param();
    test_pointer_as_return_value();

    return 0;
}

OriginalL'auteur

Un pointeur de fonction est une variable qui contient l'adresse d'une fonction. Depuis, il est un pointeur de variable mais avec quelques restreint de propriétés, vous pouvez l'utiliser un peu comme vous le feriez pour tout autre pointeur de variable dans la structure des données.

La seule exception est, je pense, le traitement de la fonction pointeur pointant vers autre chose qu'une valeur unique. Faire de l'arithmétique des pointeurs par incrémentation ou la décrémentation d'un pointeur de fonction ou en ajoutant ou en supprimant un décalage d'un pointeur de fonction n'est pas vraiment d'aucune utilité comme un pointeur de fonction des points que pour une seule chose, le point d'entrée d'une fonction.

De la taille d'un pointeur de fonction variable, le nombre d'octets occupés par la variable, peut varier en fonction de l'architecture sous-jacente, par exemple x32 ou x64 ou quoi que ce soit.

La déclaration d'un pointeur de fonction variable doit spécifier le même genre d'information que d'une déclaration de fonction pour que le compilateur C de faire les types de contrôles qu'il le fait normalement. Si vous ne spécifiez pas une liste de paramètres dans la déclaration/définition du pointeur de fonction, le compilateur C ne sera pas en mesure de vérifier l'utilisation de paramètres. Il ya des cas où cette absence de vérification peut être utile, cependant, rappelez-vous qu'un filet de sécurité a été supprimé.

Quelques exemples:

int func (int a, char *pStr);    //declares a function

int (*pFunc)(int a, char *pStr);  //declares or defines a function pointer

int (*pFunc2) ();                 //declares or defines a function pointer, no parameter list specified.

int (*pFunc3) (void);             //declares or defines a function pointer, no arguments.

Les deux premiers declararations sont un peu similaire:

• func est une fonction qui prend un int et un char * et renvoie un int
• pFunc est un pointeur de fonction à laquelle est attribuée l'adresse d'une fonction qui prend un int et un char * et renvoie un int

Donc, à partir de ce qui précède, nous pourrions avoir une ligne de source, dans lequel l'adresse de la fonction func() est affecté à la fonction pointeur de variable pFunc comme dans pFunc = func;.

Notez la syntaxe utilisée avec un pointeur de fonction déclaration/définition dans laquelle les parenthèses sont utilisées pour surmonter le naturel de règles de priorité des opérateurs.

int *pfunc(int a, char *pStr);    //declares a function that returns int pointer
int (*pFunc)(int a, char *pStr);  //declares a function pointer that returns an int

Plusieurs Exemples D'Utilisation

Quelques exemples de l'utilisation d'un pointeur de fonction:

int (*pFunc) (int a, char *pStr);    //declare a simple function pointer variable
int (*pFunc[55])(int a, char *pStr); //declare an array of 55 function pointers
int (**pFunc)(int a, char *pStr);    //declare a pointer to a function pointer variable
struct {                             //declare a struct that contains a function pointer
    int x22;
    int (*pFunc)(int a, char *pStr);
} thing = {0, func};                 //assign values to the struct variable
char * xF (int x, int (*p)(int a, char *pStr));  //declare a function that has a function pointer as an argument
char * (*pxF) (int x, int (*p)(int a, char *pStr));  //declare a function pointer that points to a function that has a function pointer as an argument

Vous pouvez utiliser la variable longueur des listes de paramètres dans la définition d'un pointeur de fonction.

int sum (int a, int b, ...);
int (*psum)(int a, int b, ...);

Ou vous ne pouvez pas spécifier une liste de paramètres. Cela peut être utile, mais il élimine la possibilité pour le compilateur C pour effectuer des contrôles sur la liste d'arguments fournis.

int  sum ();      //nothing specified in the argument list so could be anything or nothing
int (*psum)();
int  sum2(void);  //void specified in the argument list so no parameters when calling this function
int (*psum2)(void);

C style Jette

Vous pouvez utiliser C style jette avec des pointeurs de fonction. Cependant, soyez conscient qu'un compilateur C peut être laxistes concernant les contrôles ou de fournir des avertissements plutôt que des erreurs.

int sum (int a, char *b);
int (*psplsum) (int a, int b);
psplsum = sum;               //generates a compiler warning
psplsum = (int (*)(int a, int b)) sum;   //no compiler warning, cast to function pointer
psplsum = (int *(int a, int b)) sum;     //compiler error of bad cast generated, parenthesis are required.

Comparer Pointeur de Fonction à l'Égalité

Vous pouvez vérifier qu'un pointeur de fonction est égale à une fonction particulière de l'adresse à l'aide d'un if déclaration si je ne suis pas sûr de l'utilité que pourrait l'être. D'autres opérateurs de comparaison semble avoir encore moins d'utilité.

static int func1(int a, int b) {
    return a + b;
}

static int func2(int a, int b, char *c) {
    return c[0] + a + b;
}

static int func3(int a, int b, char *x) {
    return a + b;
}

static char *func4(int a, int b, char *c, int (*p)())
{
    if (p == func1) {
        p(a, b);
    }
    else if (p == func2) {
        p(a, b, c);      //warning C4047: '==': 'int (__cdecl *)()' differs in levels of indirection from 'char *(__cdecl *)(int,int,char *)'
    } else if (p == func3) {
        p(a, b, c);
    }
    return c;
}

Un Tableau de Pointeurs de Fonction

Et si vous voulez avoir un tableau de pointeurs de fonction de chacun des éléments de la liste d'arguments a des différences, alors vous pouvez définir un pointeur de fonction avec la liste des arguments non spécifié (pas void ce qui signifie pas d'arguments mais juste non spécifiée) quelque chose comme ce qui suit si vous pouvez voir des avertissements du compilateur C. Cela fonctionne aussi pour un pointeur de fonction paramètre à une fonction:

int(*p[])() = {       //an array of function pointers
    func1, func2, func3
};
int(**pp)();          //a pointer to a function pointer


p[0](a, b);
p[1](a, b, 0);
p[2](a, b);      //oops, left off the last argument but it compiles anyway.

func4(a, b, 0, func1);
func4(a, b, 0, func2);  //warning C4047: 'function': 'int (__cdecl *)()' differs in levels of indirection from 'char *(__cdecl *)(int,int,char *)'
func4(a, b, 0, func3);

    //iterate over the array elements using an array index
for (i = 0; i < sizeof(p) / sizeof(p[0]); i++) {
    func4(a, b, 0, p[i]);
}
    //iterate over the array elements using a pointer
for (pp = p; pp < p + sizeof(p)/sizeof(p[0]); pp++) {
    (*pp)(a, b, 0);          //pointer to a function pointer so must dereference it.
    func4(a, b, 0, *pp);     //pointer to a function pointer so must dereference it.
}

C style namespace l'Aide de Global struct avec des Pointeurs de Fonction

Vous pouvez utiliser le static mot-clé pour spécifier une fonction dont le nom est portée sur le fichier, puis assigner à une variable globale comme un moyen de fournir quelque chose de similaire à la namespace fonctionnalités de C++.

Dans un fichier d'en-tête de définir une structure qui sera notre espace de noms avec une variable globale qui l'utilise.

typedef struct {
   int (*func1) (int a, int b);             //pointer to function that returns an int
   char *(*func2) (int a, int b, char *c);  //pointer to function that returns a pointer
} FuncThings;

extern const FuncThings FuncThingsGlobal;

Puis dans le fichier source C:

#include "header.h"

//the function names used with these static functions do not need to be the
//same as the struct member names. It's just helpful if they are when trying
//to search for them.
//the static keyword ensures these names are file scope only and not visible
//outside of the file.
static int func1 (int a, int b)
{
    return a + b;
}

static char *func2 (int a, int b, char *c)
{
    c[0] = a % 100; c[1] = b % 50;
    return c;
}

const FuncThings FuncThingsGlobal = {func1, func2};

Ce serait alors utilisé en indiquant le nom complet de struct global variable et le nom du membre pour accéder à la fonction. Le const modificateur est utilisé sur le monde de sorte qu'il ne peut pas être changé par accident.

int abcd = FuncThingsGlobal.func1 (a, b);

Domaines d'Application de Pointeurs de Fonction

Une bibliothèque DLL composant pourrait faire la même chose pour le style C namespace approche dans laquelle un particulier à l'interface de la bibliothèque est demandé à partir d'une méthode de fabrique dans une bibliothèque d'interface qui prend en charge la création d'un struct contenant des pointeurs de fonction.. Cette interface de la bibliothèque des charges de la demande de version de la DLL, crée une structure avec le nécessaire pointeurs de fonction, et retourne ensuite la structure de la demande de l'appelant pour les utiliser.

typedef struct {
    HMODULE  hModule;
    int (*Func1)();
    int (*Func2)();
    int(*Func3)(int a, int b);
} LibraryFuncStruct;

int  LoadLibraryFunc LPCTSTR  dllFileName, LibraryFuncStruct *pStruct)
{
    int  retStatus = 0;   //default is an error detected

    pStruct->hModule = LoadLibrary (dllFileName);
    if (pStruct->hModule) {
        pStruct->Func1 = (int (*)()) GetProcAddress (pStruct->hModule, "Func1");
        pStruct->Func2 = (int (*)()) GetProcAddress (pStruct->hModule, "Func2");
        pStruct->Func3 = (int (*)(int a, int b)) GetProcAddress(pStruct->hModule, "Func3");
        retStatus = 1;
    }

    return retStatus;
}

void FreeLibraryFunc (LibraryFuncStruct *pStruct)
{
    if (pStruct->hModule) FreeLibrary (pStruct->hModule);
    pStruct->hModule = 0;
}

et il pourrait être utilisé comme:

LibraryFuncStruct myLib = {0};
LoadLibraryFunc (L"library.dll", &myLib);
// ....
myLib.Func1();
// ....
FreeLibraryFunc (&myLib);

La même approche peut être utilisée pour définir un résumé du matériel de la couche de code qui utilise un modèle particulier du matériel sous-jacent. Pointeurs de fonction sont remplis avec du matériel spécifique de fonctions par une usine pour fournir le matériel des fonctionnalités spécifiques qui implémente les fonctions précisées dans l'abstrait sur le modèle de matériel. Ceci peut être utilisé pour fournir un résumé couche du matériel utilisé par le logiciel, qui appelle une fonction de fabrication afin d'obtenir le matériel spécifique à la fonction d'interface, puis utilise les pointeurs de fonction fourni pour effectuer des actions pour le matériel sous-jacent, sans avoir besoin de connaître les détails de l'application sur la cible spécifique.

Pointeurs de fonction pour créer les Délégués, les Gestionnaires et les Rappels

Vous pouvez utiliser des pointeurs de fonction comme un moyen de déléguer certaines tâches ou des fonctions. L'exemple classique en C est la comparaison de la fonction de délégué du pointeur utilisé avec la Norme de fonctions de la bibliothèque C qsort() et bsearch() de fournir le classement de l'ordre de tri d'une liste d'éléments ou d'effectuer une recherche binaire sur une liste triée des éléments. La comparaison de la fonction de délégué indique le classement de l'algorithme utilisé dans le tri ou le binaire de recherche.

Une autre utilisation est similaire à l'application d'un algorithme pour le C++ Standard Template Library conteneur.

void * ApplyAlgorithm (void *pArray, size_t sizeItem, size_t nItems, int (*p)(void *)) {
unsigned char *pList = pArray;
unsigned char *pListEnd = pList + nItems * sizeItem;
for ( ; pList < pListEnd; pList += sizeItem) {
p (pList);
}
return pArray;
}
int pIncrement(int *pI) {
(*pI)++;
return 1;
}
void * ApplyFold(void *pArray, size_t sizeItem, size_t nItems, void * pResult, int(*p)(void *, void *)) {
unsigned char *pList = pArray;
unsigned char *pListEnd = pList + nItems * sizeItem;
for (; pList < pListEnd; pList += sizeItem) {
p(pList, pResult);
}
return pArray;
}
int pSummation(int *pI, int *pSum) {
(*pSum) += *pI;
return 1;
}
//source code and then lets use our function.
int intList[30] = { 0 }, iSum = 0;
ApplyAlgorithm(intList, sizeof(int), sizeof(intList) / sizeof(intList[0]), pIncrement);
ApplyFold(intList, sizeof(int), sizeof(intList) / sizeof(intList[0]), &iSum, pSummation);

Est un autre exemple avec la GUI code source, dans lequel un gestionnaire pour un événement particulier est inscrit en fournissant un pointeur de fonction qui est en fait appelée lorsque l'événement se produit. Microsoft MFC-cadre avec son message de cartes utilise quelque chose de semblable à gérer les messages sont livrés à une fenêtre ou d'un fil.

Asynchrone fonctions qui nécessitent un rappel sont similaires à un gestionnaire d'événement. L'utilisateur de l'asynchrone appels de fonction les fonctions asynchrones pour commencer un peu d'action et fournit un pointeur de fonction qui asynchrone fonction d'appel une fois que l'action est terminée. Dans ce cas, l'événement est asynchrone fonction de l'achèvement de sa tâche.

OriginalL'auteur

Depuis des pointeurs de fonction sont souvent tapé rappels, vous pouvez avoir un coup d'oeil à type de coffre-fort rappels. La même chose s'applique aux points d'entrée, etc de fonctions qui ne sont pas des rappels.

C est assez volage et de pardonner en même temps 🙂

OriginalL'auteur