Que fait un typedef avec la parenthèse comme “typedef int (f)(void)” signifie? Est-ce un prototype de fonction?

La première parenthèses sont superflus - c'est équivalent à:

typedef int fc_name(void);

je ne pense pas que cela n'a rien d'utile, bien que je ne peux pas obtenir de GCC pour s'en plaindre sur son propre.

Cela signifie que fc_name est un alias pour un type de fonction qui ne prend pas d'arguments et retourne un int. Elle n'est pas directement tout ce qui utile, si vous pouvez déclarer, par exemple, la rand() fonction à l'aide de:

fc_name rand;

Vous ne pouvez pas utiliser le typedef dans une définition de fonction.

Un pointeur vers la fonction de définition de type libellé:

typedef int (*fc_name)(void);

---

Ce code montre que les typedefs sans l'astérisque ne sont pas des pointeurs de fonction (s'adressant à un désormais supprimé alternative la réponse):

static int function(void)
{
    return 0;
}

typedef int   fc_name1 (void);
typedef int  (fc_name2)(void);
typedef int (*fc_name3)(void);

fc_name1 x = function;
fc_name2 y = function;
fc_name3 z = function;

Lors de la compilation, 'gcc' dit:

gcc -Wextra -Wall -pedantic -c -O x.c
x.c:10:1: error: function ‘x’ is initialized like a variable
x.c:11:1: error: function ‘y’ is initialized like a variable

---

Et ce code montre que vous pouvez en effet utiliser fc_name *var = funcname; comme suggéré par jamesdlin:

static int function(void)
{
    return 0;
}

typedef int   fc_name1 (void);
typedef int  (fc_name2)(void);
typedef int (*fc_name3)(void);

fc_name1  x_0 = function;
fc_name1 *x_1 = function;
fc_name2  y_0 = function;    //Damn Bessel functions - and no <math.h>
fc_name2 *y_1 = function;    //Damn Bessel functions - and no <math.h>
fc_name3  z   = function;

À l'aide de y0, y1 GCC génère des avertissements:

x.c:12:11: warning: conflicting types for built-in function ‘y0’
x.c:13:11: warning: built-in function ‘y1’ declared as non-function

---

Et, en s'appuyant sur le commentaire de schot:

static int function(void)
{
    return 0;
}

typedef int   fc_name1 (void);
typedef int  (fc_name2)(void);
typedef int (*fc_name3)(void);

fc_name1  x_0 = function;   //Error
fc_name1 *x_1 = function;   //x_1 is a pointer to function
fc_name1  x_2;              //Declare int x_2(void);
fc_name1 *x_3 = x_2;        //Declare x_3 initialized with x_2

fc_name2  y_0 = function;   //Damn Bessel functions - and no <math.h>
fc_name2 *y_1 = function;   //Damn Bessel functions - and no <math.h>
fc_name1  y_2;              //Declare int y_2(void);
fc_name1 *y_3 = x_2;        //Declare y_3 initialized with y_2

fc_name3  z   = function;

Intéressant - les coins sombres de la C est trop trouble, en effet.

Je n'ai encore jamais vu ce fait à un typedef nom, mais les parenthèses autour du nom d'un fonction sont utiles pour empêcher qu'elle soit développée comme une fonction-comme macro du même nom. Par exemple, le isxxx fonctions dans ctype.h sont définis comme les fonctions et macros. C'est donc un pointeur vers isalpha. Mais comment fonctionne la bibliothèque C définir le hors-ligne isalpha? Sans doute comme cela:

#include <ctype.h>

int
(isalpha)(int c)
{
    return isalpha(c);
}

L'utilisation de isalpha dans le corps de la fonction est développée comme une macro, l'utilisation de la fonction d'en-tête n'est-ce pas.

  1 #include <stdio.h>
  2 
  3 
  4 typedef int (fc_name)(void);
  5 
  6 
  7 
  8 int test_func1 ()
  9 {
 10     printf("\n test_func1 called\n");
 11 
 12     return 0;
 13 }
 14 
 15 int test_func2 (void)
 16 {
 17     printf("\n test_func2 called\n");
 18     return 0;
 19 }
 20 
 21 int handler_func(fc_name *fptr)
 22 {
 23     //Call the actual function
 24     fptr();
 25 }
 26 
 27 int main(void)
 28 {
 29     fc_name  *f1, *f2;
 30 
 31     f1 = test_func1;
 32     f2 = test_func2;
 33 
 34     handler_func(f1);
 35     handler_func(f2);
 36 
 37     printf("\n test complete\n");
 38 
 39     return 0;
 40 }

De SORTIE:-

 test_func1 called

 test_func2 called

 test complete

---

De sorte que la définition de type pour qui j'ai interrogé à propos, (Ligne n ° 4 ici) représente un
type de fonction et n'est pas le même que le pointeur de la fonction définition de type.
Ce genre de typedef n'a pas beaucoup d'importance. Ils sont utilisés comme un
standard de style ou tout simplement pour créer de la dissimulation de l'intentionnellement 😉