L'Union est un type de données défini par l'utilisateur en langage C qui peut contenir des éléments des différents types de données, tout comme la structure. Mais contrairement aux structures, tous les membres de l’union C sont stockés dans le même emplacement mémoire. Pour cette raison, un seul membre peut stocker des données sur l’instance donnée.
Syntaxe de l'Union en C
La syntaxe de l'union en C peut être divisée en trois étapes qui sont les suivantes :
Déclaration syndicale C
Dans cette partie, nous déclarons uniquement le modèle de l'union, c'est-à-dire que nous déclarons uniquement les noms et types de données des membres ainsi que le nom de l'union. Aucune mémoire n'est allouée au syndicat dans la déclaration.
union union_name { datatype member1 ; datatype member2 ; ... };> Gardez à l’esprit que nous devons toujours terminer la déclaration d’union par un point-virgule.
Différentes façons de définir une variable d'union
Nous devons définir une variable de type syndicat pour commencer à utiliser les membres du syndicat. Il existe deux méthodes permettant de définir une variable d'union.
- Avec déclaration syndicale
- Après la déclaration syndicale
1. Définition de la variable Union avec déclaration
union union_name { datatype member1; datatype member2; ... } var1, var2, ...;> 2. Définition de la variable Union après déclaration
union union_name var1, var2, var3 ...;>
où nom_syndicat est le nom d'un syndicat déjà déclaré.
Accéder aux membres du syndicat
Nous pouvons accéder aux membres d'un syndicat en utilisant l'opérateur point ( . ) tout comme les structures.
var1.member1 ;>
où var1 est le variable d'union et membre1 est le membre du syndicat .
La méthode ci-dessus pour accéder aux membres du syndicat fonctionne également pour les syndicats imbriqués.
var1.member1.memberA;>
Ici,
- var1 est une variable syndicale.
- membre1 est membre du syndicat.
- membreA est membre du membre1.
Initialisation de l'Union en C
L'initialisation d'une union est l'initialisation de ses membres en lui attribuant simplement la valeur.
var1.member1 = some_value ;>
Une chose importante à noter ici est que un seul membre peut contenir une valeur à un instant donné.
Exemple d'union
C
// C Program to demonstrate how to use union> #include> // union template or declaration> union> un {> >int> member1;> >char> member2;> >float> member3;> };> // driver code> int> main()> {> >// defining a union variable> >union> un var1;> >// initializing the union member> >var1.member1 = 15;> >printf>(>'The value stored in member1 = %d'>,> >var1.member1);> >return> 0;> }> |
>
>Sortir
The value stored in member1 = 15>
Taille du syndicat
La taille de l’union sera toujours égale à la taille du plus grand membre du tableau. Tous les éléments de moindre taille peuvent stocker les données dans le même espace sans aucun débordement.
Allocation de mémoire dans C Union
Exemple 1 : programme C pour trouver la taille de l'union
C
// C Program to find the size of the union> #include> // declaring multiple unions> union> test1 {> >int> x;> >int> y;> } Test1;> union> test2 {> >int> x;> >char> y;> } Test2;> union> test3 {> >int> arr[10];> >char> y;> } Test3;> // driver code> int> main()> {> >// finding size using sizeof() operator> >int> size1 =>sizeof>(Test1);> >int> size2 =>sizeof>(Test2);> >int> size3 =>sizeof>(Test3);> >printf>(>'Sizeof test1: %d
'>, size1);> >printf>(>'Sizeof test2: %d
'>, size2);> >printf>(>'Sizeof test3: %d'>, size3);> >return> 0;> }> |
>
>
java analyser la chaîne en intSortir
Sizeof test1: 4 Sizeof test2: 4 Sizeof test3: 40>
Différence entre la structure C et l'union C
Le tableau suivant répertorie les principales différences entre la structure et l'union en C :
| Structure | syndicat |
|---|---|
| La taille de la structure est égale ou supérieure à la taille totale de tous ses membres. | La taille du syndicat correspond à la taille de son plus grand membre. |
| La structure peut contenir des données dans plusieurs membres en même temps. | Un seul membre peut contenir des données à la fois. |
| Il est déclaré à l'aide du mot-clé struct. | Il est déclaré à l'aide du mot-clé union. |
FAQ sur les syndicats C
1. Quelle est la taille du syndicat donné ?
union un { int a; int arr[20]; }> Réponse : La taille de l'union donnée est de 20 x 4 octets = 80 octets. Même si le tableau est une collection d’éléments de données similaires, il est considéré comme une seule entité par le compilateur C.
2. Pouvons-nous stocker des données chez plusieurs membres du syndicat en même temps ?
Non, nous ne pouvons stocker des données que sur un seul membre à la fois. Par exemple, dans le programme C suivant, x et y partagent le même emplacement. Si nous modifions x, nous pouvons voir les changements se refléter dans y.
C
connexion à la base de données en java
// C program to check if we can store data in multiple union> // members> #include> // Declaration of union is same as structures> union> test {> >int> x, y;> };> int> main()> {> >// A union variable t> >union> test t;> >t.x = 2;>// t.y also gets value 2> >printf>(>'After making x = 2:
x = %d, y = %d
'>, t.x,> >t.y);> >t.y = 10;>// t.x is also updated to 10> >printf>(>'After making y = 10:
x = %d, y = %d
'>, t.x,> >t.y);> >return> 0;> }> |
>
>Sortir
After making x = 2: x = 2, y = 2 After making y = 10: x = 10, y = 10>
3. Quelles sont les applications des syndicats ?
Les unions peuvent être utiles dans de nombreuses situations où nous souhaitons utiliser la même mémoire pour deux membres ou plus. Par exemple, supposons que nous souhaitions implémenter une structure de données arborescente binaire dans laquelle chaque nœud feuille a une valeur de données double, tandis que chaque nœud interne a des pointeurs vers deux enfants, mais pas de données. Si nous déclarons cela comme suit :
C
struct> NODE {> >struct> NODE* left;> >struct> NODE* right;> >double> data;> };> |
>
>
alors chaque nœud nécessite 16 octets, la moitié des octets étant gaspillés pour chaque type de nœud. D'un autre côté, si nous déclarons un nœud comme suit, nous pouvons alors économiser de l'espace.
C
struct> NODE {> >bool> is_leaf;> >union> {> >struct> {> >struct> NODE* left;> >struct> NODE* right;> >} internal;> >double> data;> >} info;> };> |
>
>