Pourquoi ne pointeur de fonction des définitions de travail avec un certain nombre de signes & '&' ou des astérisques"*'?

Pourquoi faire les travaux suivants?

void foo() {
    cout << "Foo to you too!\n";
};

int main() {
    void (*p1_foo)() = foo;
    void (*p2_foo)() = *foo;
    void (*p3_foo)() = &foo;
    void (*p4_foo)() = *&foo;
    void (*p5_foo)() = &*foo;
    void (*p6_foo)() = **foo;
    void (*p7_foo)() = **********************foo;

    (*p1_foo)();
    (*p2_foo)();
    (*p3_foo)();
    (*p4_foo)();
    (*p5_foo)();
    (*p6_foo)();
    (*p7_foo)();
}
InformationsquelleAutor Jimmy | 2011-08-01
  1. 207

    Il ya quelques morceaux de ce qui permet à tous de ces combinaisons d'opérateurs de travailler de la même façon.

    La raison fondamentale de l'ensemble de ces travaux est qu'une fonction (comme foo) est implicitement converti en un pointeur vers la fonction. C'est pourquoi void (*p1_foo)() = foo; travaux: foo est implicitement converti en un pointeur à lui-même et que le pointeur est attribué à p1_foo.

    Unaire &, lorsqu'il est appliqué à une fonction renvoie un pointeur vers la fonction, tout comme il donne l'adresse d'un objet lorsqu'il est appliqué à un objet. Pour les pointeurs de fonctions ordinaires, il est toujours redondante, car de l'implicite de la fonction à la fonction de pointeur de la conversion. En tout cas, c'est pourquoi void (*p3_foo)() = &foo; œuvres.

    Unaire *, lorsqu'il est appliqué à un pointeur de fonction, les rendements de la pointe-à la fonction, tout comme il donne de la pointe-à l'objet lorsqu'il est appliqué à un simple pointeur vers un objet.

    Ces règles peuvent être combinés. Considérez votre avant-dernier exemple, **foo:

    • D'abord, foo est implicitement converti en un pointeur sur lui-même et le premier * est appliquée à la fonction de pointeur, rendement de la fonction foo de nouveau.
    • Ensuite, le résultat est à nouveau implicitement converti en un pointeur sur lui-même et la deuxième * est appliquée, de nouveau rendement de la fonction foo.
    • Il est alors implicitement converti en un pointeur de fonction à nouveau et affectée à la variable.

    Vous pouvez ajouter autant de *s que vous le souhaitez, le résultat est toujours le même. Le plus *s, plus on rit.

    On peut aussi considérer votre cinquième exemple, &*foo:

    • D'abord, foo est implicitement converti en un pointeur sur lui-même; unaire * est appliqué, donnant foo de nouveau.
    • Ensuite, le & est appliqué à foo, ce qui donne un pointeur vers foo, qui est affectée à la variable.

    La & ne peut être appliqué à une fonction, et non à une fonction qui a été converti en un pointeur de fonction (à moins, bien sûr, la fonction de pointeur est une variable, auquel cas le résultat est un pointeur vers un pointeur à une fonction; par exemple, vous pourriez ajouter à votre liste void (**pp_foo)() = &p7_foo;).

    C'est pourquoi &&foo ne fonctionne pas: &foo n'est pas une fonction, c'est un pointeur de fonction qui est une rvalue. Cependant, &*&*&*&*&*&*foo serait, comme le ferait &******&foo, parce que dans ces deux expressions de la & est toujours appliqué à une fonction et non pas à une rvalue pointeur de fonction.

    Notez également que vous n'avez pas besoin d'utiliser le unaire * de faire l'appel via le pointeur de fonction; les deux (*p1_foo)(); et (p1_foo)(); avoir le même résultat, à nouveau en raison de la fonction à la fonction de pointeur de conversion.

    • De sorte que le nom de la fonction en elle-même est vraiment un pointeur de fonction, droite? Si oui, qui efface les différences entre les p1, p2, p6 et p7 (c'est à dire il n'y a aucun). Ce à propos des références à des pointeurs de fonction? Est-il une différence entre p3, p4 et p5?
    • Ce ne sont pas des références à des pointeurs de fonction, ils sont juste des pointeurs de fonction. &foo prend l'adresse de foo, ce qui résulte en un pointeur de fonction de pointage à foo, que l'on pourrait attendre.
    • J'ai mis à jour la réponse avec une plus correct (et beaucoup plus long) une explication. Il suffit de dire que les pointeurs de fonction en C et C++ sont bizarres.
    • Aha, ce serait plus logique. C'est pourquoi vous ne pouvez pas avoir deux &'s à côté de l'autre? Est-ce vrai que, en général, vous ne pouvez pas prendre l'adresse d'une adresse? Il me semble que l'adresse doit avoir une adresse qui est adressable... si cette abstraction du sens.
    • Le vôtre est vraiment une excellente réponse. Je suppose qu'il s'avère que vous faites un certain nombre de *s et &s mélangés ensemble (non pas que vous voulez), juste aussi longtemps que vous n'avez pas deux &s dans une rangée. Mais si "unaire &, lorsqu'il est appliqué à une fonction renvoie un pointeur vers la fonction, tout comme il donne l'adresse d'un objet lorsqu'il est appliqué à un objet" ne devriez-vous pas être en mesure de la chaîne de deux &s dans une rangée?
    • Vous ne pouvez pas la chaîne & opérateurs pour les objets: étant donné int p;, &p renvoie un pointeur vers p et est une rvalue expression; la & opérateur nécessite une lvalue expression.
    • (Il y a un certain nombre de bonnes explications de ce lvalues et rvalues sont dans les réponses à "Ce sont des rvalues, lvalues, xvalues, glvalues, et prvalues?" Cette question traite de C++0x fonctionnalités, mais les réponses ne un bon travail en expliquant la différence entre les rvalues et lvalues ainsi.).
    • Je suis en désaccord. Le plus *'s, le moins joyeux.
    • Veuillez ne pas modifier la syntaxe de mes exemples. J'ai choisi les exemples très précisément à démontrer les caractéristiques de la langue.
    • Lors de l'appel de la fonction de pointeur, les accolades ne sont pas nécessaires, si elle fournit un indice pour l'homme que la définition d'une fonction pour que le nom n'est pas susceptible d'être trouvé.
    • Il n'y a vraiment aucune raison de déréférencement de pointeurs de fonction avant d'appeler à travers eux. La seule raison pour laquelle j'ai fait dans cette réponse, c'est à souligner, notamment syntaxiques caractéristiques et de réduire les différences entre les exemples pour le nombre minimal de différences nécessaires pour démontrer ce que je suis en train d'expliquer. E. g., dans la dernière phrase, nous pourrions tout aussi bien dire p1_foo() au lieu de (p1_foo)(), mais le "extra" les parenthèses de la rendre plus la syntaxe est similaire à (*p1_foo)(), à qui nous faisons une comparaison.
    • Comme une note côté, la norme stipule explicitement qu'une combinaison de &* annuler les uns les autres (6.5.3.2): "The unary & operator yields the address of its operand." /--/ "If the operand is the result of a unary * operator, neither that operator nor the & operator is evaluated and the result is as if both were omitted, except that the constraints on the operators still apply and the result is not an lvalue.".

    InformationsquelleAutor James McNellis
  2. 5

    Je pense que c'est également utile de se rappeler que C est juste une abstraction de la machine et c'est l'un des endroits où l'abstraction est une fuite.

    Du point de vue de l'ordinateur, une fonction est une adresse mémoire qui, s'il est exécuté, il s'acquitte d'autres instructions. Donc une fonction en C est lui-même modélisé comme une adresse, ce qui a probablement conduit à la conception qu'une fonction est "identique" à l'adresse qu'il indique.

    InformationsquelleAutor madumlao