Syndicats C

Unions C

Dans ce didacticiel, vous découvrirez les unions en programmation C. Plus précisément, comment créer des syndicats, accéder à ses membres et apprendre les différences entre les syndicats et les structures.

Une union est un type défini par l'utilisateur similaire aux structures en C à l'exception d'une différence clé.

Les structures allouent suffisamment d'espace pour stocker tous leurs membres, alors que les syndicats ne peuvent contenir qu'une seule valeur de membre à la fois .

Comment définir une union ?

Nous utilisons le union mot-clé pour définir les unions. Voici un exemple :

union car
{
  char name[50];
  int price;
};

Le code ci-dessus définit un type dérivé union car .

Créer des variables d'union

Lorsqu'une union est définie, elle crée un type défini par l'utilisateur. Cependant, aucune mémoire n'est allouée. Pour allouer de la mémoire à un type d'union donné et travailler avec, nous devons créer des variables.

Voici comment nous créons des variables d'union.

union car
{
  char name[50];
  int price;
};

int main()
{
  union car car1, car2, *car3;
  return 0;
}

Une autre façon de créer des variables d'union est :

union car
{
  char name[50];
  int price;
} car1, car2, *car3;

Dans les deux cas, les variables d'union car1 , voiture2 , et un pointeur d'union car3 sur union car type sont créés.

Accéder aux membres d'un syndicat

Nous utilisons le . opérateur pour accéder aux membres d'un syndicat. Et pour accéder aux variables de pointeur, nous utilisons le -> opérateur.

Dans l'exemple ci-dessus,

Pour accéder au prix pour car1 , car1.price est utilisé.
Pour accéder au prix en utilisant car3 , soit (*car3).price ou car3->price peut être utilisé.

Différence entre syndicats et structures

Prenons un exemple pour montrer la différence entre syndicats et structures :

#include <stdio.h>
union unionJob
{
   //defining a union
   char name[32];
   float salary;
   int workerNo;
} uJob;

struct structJob
{
   char name[32];
   float salary;
   int workerNo;
} sJob;

int main()
{
   printf("size of union = %d bytes", sizeof(uJob));
   printf("\nsize of structure = %d bytes", sizeof(sJob));
   return 0;
}

Sortie

size of union = 32
size of structure = 40

Pourquoi cette différence dans la taille des variables d'union et de structure ?

Ici, la taille de sJob est de 40 octets car

la taille de name[32] est de 32 octets
la taille de salary est de 4 octets
la taille de workerNo est de 4 octets

Cependant, la taille de uJob est de 32 octets. C'est parce que la taille d'une variable union sera toujours la taille de son plus grand élément. Dans l'exemple ci-dessus, la taille de son plus grand élément, (name[32] ), est de 32 octets.

Avec un syndicat, tous les membres partagent la même mémoire .

Exemple :Accéder aux membres de l'Union

#include <stdio.h>
union Job {
   float salary;
   int workerNo;
} j;

int main() {
   j.salary = 12.3;

   // when j.workerNo is assigned a value,
   // j.salary will no longer hold 12.3
   j.workerNo = 100;

   printf("Salary = %.1f\n", j.salary);
   printf("Number of workers = %d", j.workerNo);
   return 0;
}

Sortie

Salary = 0.0
Number of workers = 100

Pour savoir où les unions sont utilisées, consultez Pourquoi avons-nous besoin d'unions C ?

C Structure et fonction Gestion des fichiers C

Langue C