typedef versus #define en C

typedef : el typedef se usa para dar un nuevo nombre al tipo de datos. Por ejemplo,

// C program to demonstrate typedef
#include <stdio.h>
  
// After this line BYTE can be used
// in place of unsigned char
typedef unsigned char BYTE;
  
int main()
{
    BYTE b1, b2;
    b1 = 'c';
    printf("%c ", b1);
    return 0;
}

Producción:

c

#define en C es una directiva que se usa para #definir alias.

// C program to demonstrate #define
#include <stdio.h>
  
// After this line HYD is replaced by
// "Hyderabad"
#define HYD "Hyderabad"
  
int main()
{
    printf("%s ", HYD);
    return 0;
}

Producción:

Hyderabad

Diferencia entre typedef y #define:

1. typedef se limita a dar nombres simbólicos solo a tipos, mientras que #define también se puede usar para definir un alias para valores, por ejemplo, puede definir 1 como UNO, 3.14 como PI, etc.
2. El compilador realiza la interpretación de typedef, mientras que el preprocesador realiza las declaraciones #define.
3. #define no debe terminar con punto y coma, pero typedef debe terminar con punto y coma.
4. #define simplemente copiará y pegará los valores de definición en el punto de uso, mientras que typedef es la definición real de un nuevo tipo.
5. typedef sigue la regla de alcance, lo que significa que si se define un nuevo tipo en un alcance (dentro de una función), entonces el nombre del nuevo tipo solo será visible hasta que el alcance esté allí. En el caso de #define, cuando el preprocesador encuentra #define, reemplaza todas las ocurrencias, después de eso (no se sigue ninguna regla de alcance).

// C program to demonstrate importance
// of typedef over #define for data types
#include <stdio.h>
typedef char* ptr;
#define PTR char*
int main()
{
    ptr a, b, c;
    PTR x, y, z;
    printf("sizeof a:%zu\n" ,sizeof(a) );
    printf("sizeof b:%zu\n" ,sizeof(b) );
    printf("sizeof c:%zu\n" ,sizeof(c) );
    printf("sizeof x:%zu\n" ,sizeof(x) );
    printf("sizeof y:%zu\n" ,sizeof(y) );
    printf("sizeof z:%zu\n" ,sizeof(z) );
    return 0;
}

Producción:

sizeof a:8
sizeof b:8
sizeof c:8
sizeof x:8
sizeof y:1
sizeof z:1

De la salida del programa anterior, el tamaño de «a», que es un puntero, es 8 (en una máquina donde los punteros se almacenan utilizando 8 bytes). En el programa anterior, cuando el compilador llega a

typedef char* ptr;
ptr a, b, c;

la declaración se convierte efectivamente

char *a, *b, *c;

Esto declara a, b, c como char*.

Por el contrario, #define funciona así:

#define PTR char*
PTR x, y, z;

la declaración se convierte efectivamente

char *x, y, z;

Esto hace que x, y y z sean diferentes, ya que x es un puntero a un carácter, mientras que y y z son variables de carácter. Cuando declaramos macros con punteros mientras definimos si declaramos más de un identificador, la definición real se le da al primer identificador y para el resto se da una definición que no es de puntero. En el caso anterior, x se declarará como char*, por lo que su tamaño es el tamaño de un puntero, mientras que y y z se declararán como char, por lo que su tamaño será de 1 byte.

Este artículo es una contribución de HARISH KUMAR . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.