Pointer de fonction de passage

Je suis un peu confus quant à la façon dont je voudrais passer un pointeur vers un pointeur de fonction. J'ai une fonction qui prend un pointeur vers une fonction que je comprends sans problème (ExecBlock). Mais je me suis donné un autre prototype d'une fonction (ExecBlock2) qui prend la déréférencé-pointeur (je ne sais pas exactement ce que c'est) et prend également l'argument si elle est adoptée en fonction de a tout. Si quelqu'un pouvait expliquer la priorité et exactement ce déréférencement d'un pointeur de fonction serait de le faire. N'est-ce pas juste de passage de la fonction elle-même?. Ce n' (void *) dans ce cas?

int ExecBlock (void (*f) (void), int isSet)
{
    return ExecBlock2( HOW TO PASS HERE? , NULL, isSet);
}

int ExecBlock2(void *(*f)(void *), void *arg, int isSet)
{
    ... more code
}

Merci!

source d'informationauteur ThePedestrian

argument-passing c c++function pointers

32
```
void (*f) (void)
```
signifie le pointeur de fonction sans arguments de retour void.
```
void *(*f)(void *)
```
signifie pointeur de fonction prenant un pointeur void et de retourner un pointeur void.

Depuis les types sont différents, le compilateur ne vous permettra pas de passer de l'un à l'autre sans moulage. (À noter que le casting n'est pas vraiment le droit de réponse ici, et comme @detly points, entraîne un comportement non défini.)

Comme pour un déréférencement de pointeurs de fonctions, vous n'avez pas explicitement à mettre un "*" devant un pointeur de fonction à appeler. Par exemple, vous pouvez appeler votre pointeur de fonction f tout en faisant le
```
f();
```
Un pointeur de fonction exemple

Dire que vous avez une fonction fque vous souhaitez passer à une fonction appelée takes_a_function.
takes_a_function aura probablement un type comme
```
void takes_a_function(void (*f)(void *data), void *data);
```
Avis, comment il y a deux arguments pour takes_a_functionun pointeur de fonction, et un vide pointeur vers des données. À noter également que la fonction f arrive à prendre un vide pointeur en argument. L'idée est que vous pouvez transmettre les données à takes_a_functionet il va le transmettre à f. Par exemple, takes_a_function pourrait être défini comme
```
void takes_a_function(void (*f)(void *), void *data) {
  f(data);
}
```
Maintenant, nous allons écrire une fonction pour passer à takes_a_function. Notre fonction, il suffit d'imprimer un int qui est passé.
```
void prints_an_int(void *data) {
  //The idiom for converting a void pointer to another kind
  //of pointer.  NO NEED TO CAST.  Note this behavior is only
  //defined if the pointer data really does point to an int.
  int *i = data;
  printf("%d", *i);
}

int i = 0;
takes_a_function(prints_an_int, &i);
```
Un couple de points clés à propos de cet exemple:
- prints_an_int a le même type que le pointeur de fonction prévu par takes_a_function. Pas besoin de cast.
- Il n'y a pas besoin d'utiliser le & à l'opérateur de créer une référence à une fonction. C'est pourquoi nous pouvons passer prints_an_int à takes_a_function directement. Mais on pourrait aussi dire takes_a_function(&prints_an_int, &i)et ce serait le même.
- void* signifie fondamentalement "pointeur de type inconnu." Pour réellement faire quelque chose avec elle, vous devez affecter une variable de type void* à un autre pointeur de variable dont le type que vous attendez. Ce n'est garantie que si vous avez réellement passer dans le bon type de pointeur! Dans cet exemple, nous pouvons attribuer data à un int*puisque les données n'a vraiment point à un int. Si vous voulez plus de données que juste un entier, un modèle commun est de créer votre propre type struct qui inclut tous les champs que vous voulez, et de les passer à la place.
- Comme un cas particulier, le compilateur ne vous oblige pas à lancer lors de l'affectation d'annuler des pointeurs vers d'autres pointeurs et vice-versa. Mais encore une fois, vous obtenez seulement comportement défini si vous finalement de convertir un pointeur void retour vers le bon type.

Par exemple, vous avez une fonction

void * abc(void *)
{
//... 
}

int ExecBlock (void (*f) (void), int isSet)
    {
        return ExecBlock2( abc , NULL, isSet); //use name of the function which have void * as parameter type list and return type  void *   
        }

int ExecBlock2(void *(*f)(void *), void *arg, int isSet)
{
    ... more code
}

Voir la fonction de pointeurs

Vous devez vous connecter pour publier un commentaire.

Un pointeur de fonction exemple