Puntatore alla funzione typedef?

Sto imparando come caricare dinamicamente DLL ma quello che non capisco è questa riga

typedef void (*FunctionFunc)();

Ho alcune domande. Se qualcuno è in grado di risponderle, sarei grato.

1. Perché viene typedefusato?
2. La sintassi sembra strana; dopo voidnon ci dovrebbe essere un nome di funzione o qualcosa del genere? Sembra una funzione anonima.
3. È stato creato un puntatore a funzione per memorizzare l'indirizzo di memoria di una funzione?

Quindi sono confuso al momento; puoi chiarire le cose per me?

typedefè un costrutto linguistico che associa un nome a un tipo.
Lo usi nello stesso modo in cui utilizzeresti il ​​tipo originale, per esempio

  typedef int myinteger;
  typedef char *mystring;
  typedef void (*myfunc)();

usandoli come

  myinteger i;   // is equivalent to    int i;
  mystring s;    // is the same as      char *s;
  myfunc f;      // compile equally as  void (*f)();

Come puoi vedere, puoi semplicemente sostituire il nome digitato con la sua definizione data sopra.

La difficoltà sta nel puntatore alla sintassi e alla leggibilità delle funzioni in C e C ++ e la typedefpossibilità di migliorare la leggibilità di tali dichiarazioni. Tuttavia, la sintassi è appropriata, poiché le funzioni - a differenza di altri tipi più semplici - possono avere un valore e parametri di ritorno, quindi la dichiarazione a volte lunga e complessa di un puntatore alla funzione.

La leggibilità può iniziare a essere davvero complicata con i puntatori agli array di funzioni e ad alcuni altri sapori ancora più indiretti.

Per rispondere alle tue tre domande

• Perché viene utilizzato typedef? Per facilitare la lettura del codice, in particolare per i puntatori a funzioni o nomi di strutture.

• La sintassi sembra strana (nel puntatore alla dichiarazione di funzione) Che la sintassi non è ovvia da leggere, almeno all'inizio. L'uso di una typedefdichiarazione invece facilita la lettura

• È stato creato un puntatore a funzione per memorizzare l'indirizzo di memoria di una funzione? Sì, un puntatore a funzione memorizza l'indirizzo di una funzione. Questo non ha nulla a che fare con il typedefcostrutto che facilita solo la scrittura / lettura di un programma; il compilatore espande semplicemente la definizione typedef prima di compilare il codice effettivo.

Esempio:

typedef int (*t_somefunc)(int,int);

int product(int u, int v) {
  return u*v;
}

t_somefunc afunc = &product;
...
int x2 = (*afunc)(123, 456); // call product() to calculate 123*456

1. typedefè usato per alias tipi; in questo caso si sta aliasing FunctionFunca void(*)().

2. In effetti la sintassi sembra strana, date un'occhiata a questo:

   typedef   void      (*FunctionFunc)  ( );
   //         ^                ^         ^
   //     return type      type name  arguments
   

3. No, questo dice semplicemente al compilatore che il FunctionFunctipo sarà un puntatore a funzione, non ne definisce uno, come questo:

   FunctionFunc x;
   void doSomething() { printf("Hello there\n"); }
   x = &doSomething;
   
   x(); //prints "Hello there"
   

Senza la typedefparola, in C ++ la dichiarazione dichiarerebbe una variabile FunctionFuncdi tipo pointer per funzionare senza argomenti, restituendo void.

Con typedefesso invece si definisce FunctionFunccome un nome per quel tipo.

Se è possibile utilizzare C ++ 11, è possibile che si desideri utilizzare std::functione la usingparola chiave.

using FunctionFunc = std::function<void(int arg1, std::string arg2)>;

#include <stdio.h>
#include <math.h>

/*
To define a new type name with typedef, follow these steps:
1. Write the statement as if a variable of the desired type were being declared.
2. Where the name of the declared variable would normally appear, substitute the new type name.
3. In front of everything, place the keyword typedef.
*/

// typedef a primitive data type
typedef double distance;

// typedef struct 
typedef struct{
    int x;
    int y;
} point;

//typedef an array 
typedef point points[100]; 

points ps = {0}; // ps is an array of 100 point 

// typedef a function
typedef distance (*distanceFun_p)(point,point) ; // TYPE_DEF distanceFun_p TO BE int (*distanceFun_p)(point,point)

// prototype a function     
distance findDistance(point, point);

int main(int argc, char const *argv[])
{
    // delcare a function pointer 
    distanceFun_p func_p;

    // initialize the function pointer with a function address
    func_p = findDistance;

    // initialize two point variables 
    point p1 = {0,0} , p2 = {1,1};

    // call the function through the pointer
    distance d = func_p(p1,p2);

    printf("the distance is %f\n", d );

    return 0;
}

distance findDistance(point p1, point p2)
{
distance xdiff =  p1.x - p2.x;
distance ydiff =  p1.y - p2.y;

return sqrt( (xdiff * xdiff) + (ydiff * ydiff) );
}

Per caso generale di sintassi si può guardare allegato A dello standard ANSI C .

Nella forma Backus-Naur da lì, puoi vedere che typedefha il tipo storage-class-specifier.

Nel tipo declaration-specifierspuoi vedere che puoi mescolare molti tipi di identificatore, il cui ordine non ha importanza.

Ad esempio, è corretto dire,

long typedef long a;

per definire il tipo acome alias per long long. Quindi, per capire il typedef sull'uso esauriente, è necessario consultare un modulo backus-naur che definisce la sintassi (ci sono molte grammatiche corrette per ANSI C, non solo quella di ISO).

Quando si utilizza typedef per definire un alias per un tipo di funzione, è necessario posizionare l'alias nello stesso punto in cui si inserisce l'identificatore della funzione. Nel tuo caso, definisci il tipo FunctionFunccome alias affinché un puntatore funzioni il cui controllo del tipo è disabilitato alla chiamata e non restituisce nulla.