Est-ce que typedef et #define sont identiques en c?

Question

Je me demande si typedef et #define sont identiques en c ?

Answer 1

typedef obéit aux règles de cadrage comme les variables, alors que define reste valide jusqu'à la fin du fichier (ou jusqu'à ce qu'un undef ).

De plus, certaines choses peuvent être faites avec typedef qui ne peut pas être fait avec define .

Exemples:

 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
 

Answer 2

Non.

#define est un jeton de préprocesseur: le compilateur lui-même ne le verra jamais.
typedef est un jeton de compilateur: le préprocesseur ne s'en soucie pas.

Vous pouvez utiliser l'un ou l'autre pour obtenir le même effet, mais il est préférable d'utiliser celui qui convient à vos besoins.

 #define MY_TYPE int
typedef int My_Type;
 

Quand les choses deviennent "poilues", l'utilisation du bon outil le rend bien

 #define FX_TYPE void (*)(int)
typedef void (*stdfx)(int);

void fx_typ(stdfx fx); /* ok */
void fx_def(FX_TYPE fx); /* error */
 

Answer 3

Non, ils ne sont pas les mêmes. Par exemple:

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

Après le prétraitement, cette ligne s'étend à

int* a, b;

J'espère que vous voyez le problème; seulement a aura le type int *; b sera déclarée plain int (parce que l' * est associée à la déclaration, pas le spécificateur de type).

Voilà qui contraste avec

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

Dans ce cas, les deux a et b type int *.

Il y a des classes entières de typedefs qui ne peuvent pas être reproduites avec une macro du préprocesseur, tels que les pointeurs de fonctions ou de tableaux:

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

Essayez de faire ça avec une macro du préprocesseur.

Answer 4

#define définit les macros.
typedef définit les types.

Maintenant dire que, voici quelques différences:

Avec #define vous pouvez définir des constantes qui peuvent être utilisés au moment de la compilation. Les constantes peuvent être utilisées avec #ifdef pour vérifier la façon dont le code est compilé, et de se spécialiser certains de code selon la compilation des paramètres.
Vous pouvez également utiliser des #define pour déclarer miniature trouver et remplacer des fonctions de Macro.

typedef peut être utilisé pour donner des alias de types (que vous pourriez probablement faire avec #define ), mais c'est plus sûr en raison de la trouver et de remplacer la nature de #définir des constantes.
En outre, vous pouvez utiliser la déclaration de l'avant avec typedef qui vous permet de déclarer un type qui sera utilisé, mais n'est pas encore lié au fichier que vous avez écrit.

Answer 5

Les macros du préprocesseur ("#define'") sont lexicale outil de remplacement à la "rechercher et remplacer". Ils sont totalement agnostique de la langue de programmation et de ne pas comprendre ce que vous essayez de faire. Vous pouvez y penser comme à une simple copier/coller de mécanicien, parfois c'est utile, mais vous devez les utiliser avec prudence.

Typedefs sont un langage C fonctionnalité qui vous permet de créer des alias pour les types. C'est extrêmement utile pour faire compliqué les types composés (comme les structures et pointeurs de fonction) lisible et handlable (en C++ il y a même des situations où vous devez définition de type d'un type).

Pour (3): Vous devez toujours préférer la langue dispose de plus de préprocesseur macros lorsque c'est possible! Il faut donc toujours utiliser des typedefs pour les types, et les valeurs des constantes pour les constantes. De cette façon, le compilateur peuvent réellement interagir avec vous de façon significative. Rappelez-vous que le compilateur est votre ami, vous devez donc vous en dire autant de fois que possible. Les macros du préprocesseur faire exactement le contraire de cacher votre sémantique du compilateur.