Diferencia entre Estructura y Unión en C

Estructuras en C es un tipo de datos definido por el usuario disponible en C que permite combinar elementos de datos de diferentes tipos. Las estructuras se utilizan para representar un registro. 

Definición de una estructura: para definir una estructura, debe utilizar la instrucción struct . La instrucción struct define un nuevo tipo de datos, con más o igual a un miembro. El formato de la instrucción struct es el siguiente:

   struct [structure name]
   {
       member definition;
       member definition;
       ...
       member definition;
   };
   
   (OR)

   struct [structure name]
   {
       member definition;
       member definition;
       ...
       member definition;
   }structure variable declaration;

Unión en C es un tipo de datos especial disponible en C que permite almacenar diferentes tipos de datos en la misma ubicación de memoria. Puede definir una unión con muchos miembros, pero solo un miembro puede contener un valor en un momento dado. Las uniones proporcionan una forma eficiente de usar la misma ubicación de memoria para múltiples propósitos. 

Definición de una unión: para definir una unión, debe usar la declaración de unión de la misma manera que lo hizo al definir una estructura. La declaración de unión define un nuevo tipo de datos con más de un miembro para su programa. El formato de la declaración sindical es el siguiente: 

    union [union name]
    {
       member definition;
       member definition;
       ...
       member definition;
    };
   
    (OR) 

    union [union name]
    {
       member definition;
       member definition;
       ...
       member definition;
    }union variable declaration;

Similitudes entre estructura y unión

1. Ambos son tipos de datos definidos por el usuario que se utilizan para almacenar datos de diferentes tipos como una sola unidad.
2. Sus miembros pueden ser objetos de cualquier tipo, incluidas otras estructuras y uniones o arreglos. Un miembro también puede consistir en un campo de bits.
3. Tanto las estructuras como las uniones solo admiten operadores de asignación = y sizeof. Las dos estructuras o uniones en la asignación deben tener los mismos miembros y tipos de miembros.
4. Una estructura o una unión se puede pasar por valor a las funciones y devolver por valor a las funciones. El argumento debe tener el mismo tipo que el parámetro de la función. Una estructura o unión se pasa por valor al igual que una variable escalar como parámetro correspondiente.
5. ‘.’ El operador u operador de selección, que tiene una de las precedencias más altas, se usa para acceder a variables miembro dentro de ambos tipos de datos definidos por el usuario.

Las diferencias entre la estructura y la unión se muestran a continuación en formato tabular como se muestra a continuación de la siguiente manera: 

// C program to illustrate differences
// between structure and Union
 
#include <stdio.h>
#include <string.h>
  
// declaring structure
struct struct_example
{
    int integer;
    float decimal;
    char name[20];
};
  
// declaring union
  
union union_example
{
    int integer;
    float decimal;
    char name[20];
};
  
void main()
{
    // creating variable for structure
    // and initializing values difference
    // six
    struct struct_example s={18,38,"geeksforgeeks"};
  
    // creating variable for union
    // and initializing values
    union union_example u={18,38,"geeksforgeeks"};
  
          
    printf("structure data:\n integer: %d\n"
                "decimal: %.2f\n name: %s\n",
                s.integer, s.decimal, s.name);
    printf("\nunion data:\n integer: %d\n"
                 "decimal: %.2f\n name: %s\n",
                u.integer, u.decimal, u.name);
  
  
    // difference two and three
    printf("\nsizeof structure : %d\n", sizeof(s));
    printf("sizeof union : %d\n", sizeof(u));
      
    // difference five
    printf("\n Accessing all members at a time:");
    s.integer = 183;
    s.decimal = 90;
    strcpy(s.name, "geeksforgeeks");
      
    printf("structure data:\n integer: %d\n "
                "decimal: %.2f\n name: %s\n",
            s.integer, s.decimal, s.name);
      
    u.integer = 183;
    u.decimal = 90;
    strcpy(u.name, "geeksforgeeks");
      
    printf("\nunion data:\n integer: %d\n "
                "decimal: %.2f\n name: %s\n",
            u.integer, u.decimal, u.name);
      
    printf("\n Accessing one member at time:");
      
    printf("\nstructure data:");
    s.integer = 240;
    printf("\ninteger: %d", s.integer);
      
    s.decimal = 120;
    printf("\ndecimal: %f", s.decimal);
      
    strcpy(s.name, "C programming");
    printf("\nname: %s\n", s.name);
      
    printf("\n union data:");
    u.integer = 240;
    printf("\ninteger: %d", u.integer);
      
    u.decimal = 120;
    printf("\ndecimal: %f", u.decimal);
      
    strcpy(u.name, "C programming");
    printf("\nname: %s\n", u.name);
      
    //difference four
    printf("\nAltering a member value:\n");
    s.integer = 1218;
    printf("structure data:\n integer: %d\n "
                " decimal: %.2f\n name: %s\n",
                s.integer, s.decimal, s.name);
      
    u.integer = 1218;
    printf("union data:\n integer: %d\n"
           " decimal: %.2f\n name: %s\n",
            u.integer, u.decimal, u.name);
}

Producción:

structure data:
 integer: 18
 decimal: 38.00
 name: geeksforgeeks

union data:
 integer: 18
 decimal: 0.00
 name: ?

sizeof structure: 28
sizeof union: 20

 Accessing all members at a time: structure data:
 integer: 183
 decimal: 90.00
 name: geeksforgeeks

union data:
 integer: 1801807207
 decimal: 277322871721159510000000000.00
 name: geeksforgeeks

 Accessing one member at a time:
structure data:
integer: 240
decimal: 120.000000
name: C programming

 union data:
integer: 240
decimal: 120.000000
name: C programming

Altering a member value:
structure data:
 integer: 1218
 decimal: 120.00
 name: C programming
union data:
 integer: 1218
 decimal: 0.00
 name: ?

Nota: las estructuras son mejores que las uniones, ya que la memoria se comparte en una unión, lo que genera un poco de ambigüedad. Pero técnicamente hablando, las uniones son mejores porque ayudan a ahorrar mucha memoria, lo que resulta en una ventaja general sobre las estructuras a largo plazo.
Cuestionario sobre estructuras y unión . 

Este artículo es una contribución de Harish Kumar. Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@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.