Typedef e #define lo stesso in c?

Mi chiedo se typedef e #define siano uguali in c ?

No.

#define è un token del preprocessore: il compilatore stesso non lo vedrà mai.
typedef è un token del compilatore: il preprocessore non se ne preoccupa.

Puoi usare l’uno o l’altro per ottenere lo stesso effetto, ma è meglio usare quello giusto per le tue esigenze

 #define MY_TYPE int typedef int My_Type; 

Quando le cose diventano “pelose”, usare lo strumento giusto lo rende giusto

 #define FX_TYPE void (*)(int) typedef void (*stdfx)(int); void fx_typ(stdfx fx); /* ok */ void fx_def(FX_TYPE fx); /* error */ 

typedef obbedisce alle regole di scoping proprio come le variabili, mentre define rimane valido fino alla fine del file (o fino a un undef corrispondente).

Inoltre, alcune cose possono essere fatte con typedef che non può essere fatto con define .

Esempi:

 typedef int* int_p1; int_p1 a, b, c; // a, b, and c are all int pointers. #define int_p2 int* int_p2 a, b, c; // only the first is a pointer! 

.

 typedef int a10[10]; a10 a, b, c; // create three 10-int arrays 

.

 typedef int (*func_p) (int); func_p fp // func_p is a pointer to a function that // takes an int and returns an int 

No, non sono la stessa cosa. Per esempio:

 #define INTPTR int* ... INTPTR a, b; 

Dopo la pre-elaborazione, quella linea si espande in

 int* a, b; 

Spero che tu veda il problema; solo a avrà il tipo int * ; b sarà dichiarato int plain (poiché * è associato al dichiaratore, non al specificatore del tipo).

Contrasto con

 typedef int *INTPTR; ... INTPTR a, b; 

In questo caso, sia a che b avranno tipo int * .

Esistono intere classi di typedef che non possono essere emulate con una macro del preprocessore, come i puntatori a funzioni o matrici:

 typedef int (*CALLBACK)(void); typedef int *(*(*OBNOXIOUSFUNC)(void))[20]; ... CALLBACK aCallbackFunc; // aCallbackFunc is a pointer to a function // returning int OBNOXIOUSFUNC anObnoxiousFunc; // anObnoxiousFunc is a pointer to a function // returning a pointer to a 20-element array // of pointers to int 

Prova a farlo con una macro del preprocessore.

#define definisce le macro.
typedef definisce i tipi.

Ora dicendo questo, ecco alcune differenze:

Con #define è ansible definire costanti che possono essere utilizzate in fase di compilazione. Le costanti possono essere utilizzate con #ifdef per verificare come viene compilato il codice e specializzare determinati codici in base ai parametri di compilazione.
È inoltre ansible utilizzare #define per dichiarare le funzioni macro di ricerca e sostituzione in miniatura.

typedef può essere usato per dare alias di tipi (che potreste probabilmente fare anche con #define ), ma è più sicuro a causa della natura find-and-replace delle costanti #define .
Oltre a questo, puoi usare forward declaration con typedef che ti consente di dichiarare un tipo che verrà usato, ma non è ancora collegato al file in cui stai scrivendo.

Le macro di preprocessore (” #define “) “sono uno strumento di sostituzione lessicale alla” ricerca e sostituzione “. Sono completamente agnostici del linguaggio di programmazione e non capiscono cosa stai cercando di fare. Puoi considerarli come una meccanica copia / incolla glorificata, a volte è utile, ma dovresti usarla con cura.

I typedef sono una caratteristica del linguaggio C che consente di creare alias per i tipi. Ciò è estremamente utile per rendere leggibili e gestibili tipi di composto complessi (come le strutture e i puntatori di funzione) (in C ++ ci sono anche situazioni in cui è necessario digitare un tipo).

Per (3): Dovresti sempre preferire le caratteristiche della lingua sulle macro del preprocessore quando è ansible! Quindi usa sempre typedef per i tipi e valori costanti per le costanti. In questo modo, il compilatore può effettivamente interagire con te in modo significativo. Ricorda che il compilatore è tuo amico, quindi dovresti dirlo il più ansible. Le macro preprocessore fanno esattamente l’opposto nascondendo la semantica dal compilatore.

Sono molto diversi, anche se sono spesso usati per implementare tipi di dati personalizzati (che è quello che presumo sia la questione).

Come menzionato da pmg, #define viene gestito dal pre-processore (come un’operazione di copia e incolla) prima che il compilatore veda il codice e typedef viene interpretato dal compilatore.

Una delle principali differenze (almeno per quanto riguarda la definizione dei tipi di dati) è che typedef consente un controllo più specifico del tipo. Per esempio,

 #define defType int typedef int tdType defType x; tdType y; 

Qui, il compilatore vede la variabile x come un int, ma la variabile y come un tipo di dati chiamato ‘tdType’ che ha la stessa dimensione di un int. Se hai scritto una funzione che ha preso un parametro di tipo defType, il chiamante potrebbe passare un normale int e il compilatore non conoscerebbe la differenza. Se invece la funzione utilizzava un parametro di tipo tdType, il compilatore si assicurava che una variabile del tipo corretto venisse utilizzata durante le chiamate di funzione.

Inoltre, alcuni debugger hanno la capacità di gestire typedef s, che può essere molto più utile di avere tutti i tipi personalizzati elencati come i loro tipi primitivi sottostanti (come sarebbe invece se fosse usato #define ).

AFAIK, No.

‘typedef’ ti aiuta a impostare un “alias” su un tipo di dati esistente. Per es. typedef char chr;

#define è una direttiva per il preprocessore utilizzata per definire macro o subsituzioni di pattern generali. Per es. #define MAX 100, sostituisce tutte le occorrenze di MAX con 100

No.
typedef è una parola chiave C che crea un alias per un tipo.
#define è un’istruzione pre-processore, che crea un evento di sostituzione del testo prima della compilazione. Quando il compilatore arriva al codice, la parola “#defined” originale non è più lì. #define è usato principalmente per macro e costanti globali.

Come tutti hanno detto sopra, non sono la stessa cosa. La maggior parte delle risposte indica che typedef è più vantaggioso di #define . Ma lasciatemi mettere un punto a favore di #define :
quando il tuo codice è estremamente grande, sparsi su molti file, è meglio usare #define ; aiuta nella leggibilità – puoi semplicemente pre-elaborare tutto il codice per vedere l’effettiva definizione del tipo di una variabile nel luogo della sua stessa dichiarazione.