syndicat peut être défini comme un type de données défini par l'utilisateur qui est une collection de différentes variables de différents types de données dans le même emplacement mémoire. L'union peut également être définie comme étant composée de plusieurs membres, mais un seul membre peut contenir une valeur à un moment donné.

L'union est un type de données défini par l'utilisateur, mais contrairement aux structures, elles partagent le même emplacement mémoire.

Comprenons cela à travers un exemple.

 struct abc { int a; char b; } 

Le code ci-dessus est la structure définie par l'utilisateur qui se compose de deux membres, c'est-à-dire « a » de type int et 'b' de type personnage . Lorsque nous vérifions les adresses de « a » et « b », nous avons constaté que leurs adresses sont différentes. Nous concluons donc que les membres de la structure ne partagent pas le même emplacement mémoire.

Lorsque nous définissons l'union, nous avons constaté que l'union est définie de la même manière que la structure, mais la différence est que le mot-clé union est utilisé pour définir le type de données union, tandis que le mot-clé struct est utilisé pour définir la structure. L'union contient les données membres, c'est-à-dire « a » et « b », lorsque nous vérifions les adresses des deux variables, nous avons constaté que les deux ont les mêmes adresses. Cela signifie que les membres du syndicat partagent le même emplacement mémoire.

Jetons un coup d'œil à la représentation picturale de l'allocation de mémoire.

La figure ci-dessous montre la représentation picturale de la structure. La structure compte deux membres ; c'est-à-dire que l'un est de type entier et l'autre est de type caractère. Puisque 1 bloc est égal à 1 octet ; par conséquent, la variable « a » se verra attribuer 4 blocs de mémoire tandis que la variable « b » se verra attribuer 1 bloc de mémoire.

La figure ci-dessous montre la représentation picturale des membres du syndicat. Les deux variables partagent le même emplacement mémoire et ont la même adresse initiale.

En union, les membres partageront l’emplacement mémoire. Si nous essayons d’apporter des modifications à l’un des membres, cela sera également répercuté sur l’autre membre. Comprenons ce concept à travers un exemple.

 union abc { int a; char b; }var; int main() { var.a = 66; printf('
 a = %d', var.a); printf('
 b = %d', var.b); } 

Dans le code ci-dessus, le syndicat compte deux membres, c'est-à-dire « a » et « b ». Le 'var' est une variable de type union abc. Dans le principal() méthode, nous attribuons le 66 à la variable 'a', donc var.a imprimera 66 à l'écran. Puisque « a » et « b » partagent l'emplacement mémoire, var.b imprimera ' B ' (code ascii de 66).

Décider de la taille du syndicat

La taille du syndicat est basée sur la taille du plus grand membre du syndicat.

Comprenons à travers un exemple.

 union abc{ int a; char b; float c; double d; }; int main() { printf('Size of union abc is %d', sizeof(union abc)); return 0; } 

Comme nous le savons, la taille de int est de 4 octets, la taille de char est de 1 octet, la taille de float est de 4 octets et la taille de double est de 8 octets. Étant donné que la variable double occupe la plus grande mémoire parmi les quatre variables, un total de 8 octets seront alloués dans la mémoire. Par conséquent, la sortie du programme ci-dessus serait de 8 octets.

Accéder aux membres du syndicat à l'aide de pointeurs

Nous pouvons accéder aux membres du syndicat via des pointeurs en utilisant l'opérateur flèche (->).

Comprenons à travers un exemple.

 #include union abc { int a; char b; }; int main() { union abc *ptr; // pointer variable declaration union abc var; var.a= 90; ptr = &var; printf('The value of a is : %d', ptr->a); return 0; } 

Dans le code ci-dessus, nous avons créé une variable de pointeur, c'est-à-dire *ptr, qui stocke l'adresse de la variable var. Désormais, ptr peut accéder à la variable 'a' en utilisant l'opérateur (->). Par conséquent, la sortie du code ci-dessus serait 90.

Pourquoi avons-nous besoin de syndicats C ?

Prenons un exemple pour comprendre la nécessité des syndicats C. Prenons un magasin qui propose deux articles :

• Livres
• Chemises

Les propriétaires de magasins souhaitent stocker les enregistrements des deux éléments mentionnés ci-dessus ainsi que les informations pertinentes. Par exemple, les livres incluent le titre, l'auteur, le nombre de pages, le prix et les chemises incluent la couleur, le design, la taille et le prix. La propriété « prix » est commune aux deux éléments. Le propriétaire du magasin souhaite stocker les propriétés, puis comment il stockera les enregistrements.

Initialement, ils ont décidé de stocker les enregistrements dans une structure comme indiqué ci-dessous :

 struct store { double price; char *title; char *author; int number_pages; int color; int size; char *design; }; 

La structure ci-dessus comprend tous les articles que le propriétaire du magasin souhaite stocker. La structure ci-dessus est tout à fait utilisable, mais le prix est la propriété commune des deux articles et le reste des articles est individuel. Les propriétés telles que prix, *titre, *auteur et numéro_pages appartiennent aux livres tandis que la couleur, la taille et le *design appartiennent à la chemise.

Voyons comment accéder aux membres de la structure .

 int main() { struct store book; book.title = 'C programming'; book.author = 'Paulo Cohelo'; book.number_pages = 190; book.price = 205; printf('Size is : %ld bytes', sizeof(book)); return 0; } 

Dans le code ci-dessus, nous avons créé une variable de type magasin . Nous avons attribué les valeurs aux variables titre, auteur, nombre_pages, prix mais la variable livre ne possède pas les propriétés telles que la taille, la couleur et le design. C'est donc un gaspillage de mémoire. La taille de la structure ci-dessus serait de 44 octets.

Nous pouvons économiser beaucoup d'espace si nous utilisons des syndicats.

 #include struct store { double price; union { struct{ char *title; char *author; int number_pages; } book; struct { int color; int size; char *design; } shirt; }item; }; int main() { struct store s; s.item.book.title = 'C programming'; s.item.book.author = 'John'; s.item.book.number_pages = 189; printf('Size is %ld', sizeof(s)); return 0; } 

Dans le code ci-dessus, nous avons créé une variable de type store. Puisque nous avons utilisé les unions dans le code ci-dessus, la plus grande mémoire occupée par la variable serait prise en compte pour l'allocation de mémoire. La sortie du programme ci-dessus est de 32 octets. Dans le cas des structures, nous avons obtenu 44 octets, tandis que dans le cas des unions, la taille obtenue est de 44 octets. Par conséquent, 44 octets sont supérieurs à 32 octets, ce qui permet d'économiser beaucoup d'espace mémoire.