Dans les règles de syntaxe, qu'est-ce qui rend les prototypes de fonctions qui retournent les pointeurs et les pointeurs de fonction différents?

Question

Le prototype pour définir une fonction qui renvoie un pointeur ressemble à ceci:

int * function_name(); 

En même temps, le prototype d'un pointeur de fonction ressemble à ceci:

int (*function_name)(); 

Quelles règles de syntaxe rend les deux définitions différentes? Comment la préséance entre-t-elle en jeu?

Par exemple, est

(int *) function_name(); 

un prototype pour une fonction qui renvoie un pointeur ou une fonction de pointeur? (Mon intuition est qu'elle définit une fonction qui retourne (int *), et donc est la première.)

Éditer: J'ai réalisé que ma question concerne réellement les déclarations C. Une bonne ressource pour comprendre celles-ci est http://unixwiz.net/techtips/reading-cdecl.html

Answer 1

(int *) function_name(); 

en fonction prototype est erreur de syntaxe.
Lorsque vous appelez function_name(); cette façon, il jette la valeur de retour à un int *:

int main(void) { 
    (int *) function_name(); //the return value is being casted to an `int *` 
    return 0; 
} 

Ce qui suit est une fonction qui renvoie un pointeur:

int *function_name(); 

Et ce qui suit est un pointeur de fonction c'est-à-dire un pointeur vers une fonction:

int (*function_name)(); 

Permettez-moi de citer this:

Parfois, les gens se confondre quand plus d'étoiles sont jetés:
void *(*foo)(int *);
Ici, la clé est de lire à l'envers; remarquez que l'élément le plus profond de l'expression est * foo, et que dans le cas contraire, il ressemble à une déclaration de fonction normale. * foo devrait se référer à une fonction qui retourne un void * et prend un int *. Par conséquent, foo est un pointeur vers une telle fonction.

Answer 2

Quelles règles de syntaxe rend ces deux définitions différentes?

La règle pour l'analyse est la suivante:

1. Localiser l'identifiant.
2. Toujours favoriser [] et () sur *.

Ainsi, pour int * function_name();, identifiant function_name va de pair avec la volonté () au lieu de * et donc function_name est déclarée comme fonction qui renvoie un pointeur vers int.

Pour int (*function_name)();, la force extérieure supplémentaire entre parenthèses à function_name est livré avec * plutôt que (). Donc, cela déclare function_name comme un pointeur vers la fonction qui renvoie un int.

(int *) function_name(); ne peut pas être utilisé en dehors d'une fonction. Le compilateur signale une erreur de syntaxe. En voyant (int *), le compilateur interprétera comme un opérateur de cast et function_name() comme un appel de fonction.

---

Lecture supplémentaire: Deciphering complex declaration like void (*(*f[])())().

Answer 3

OK, l'application des règles de lecture des déclarations de C (par exemple here):

int * function_name(); 

Déclare function_name en fonction renvoyant un pointeur sur int, alors que

int (* function_name)(); 

déclare nom_fonction comme pointeur à une fonction renvoyant int.