Syntaxe:
Une union est un type défini par l'utilisateur, permettant le stockage de divers types de données dans un emplacement de mémoire partagé. L'utilisation d'une union suit une syntaxe identique à une structure.
La syntaxe fondamentale est la suivante :
syndicat NomUnion {
// Déclarations des membres
Membre DataType11 ;
Membre DataType22 ;
//...
} ;
Ici, « UnionName » sert d'identifiant pour l'union qui fournit un nom unique pour référencer ce type spécifique défini par l'utilisateur. Les types de données des membres de l’union sont désignés par « DataType1 », « DataType2 », etc. Ces types de données représentent les différents types d'informations qui peuvent être stockées au sein du syndicat. Chaque membre du syndicat, désigné par des noms tels que « membre1 », « membre2 », etc., représente une donnée distincte.
Nous comprenons maintenant la syntaxe de base. Utilisons maintenant quelques exemples pour mieux comprendre cela.
Exemple 1 : utilisation de base de l'union
Le premier exemple illustre l'utilisation de base des unions en C++, montrant comment elles permettent le partage de l'espace mémoire entre différents types de données au sein d'une seule structure.
Voici un exemple:
#include
en utilisant l'espace de noms std ;
syndicat TableauUnion {
int tableauint [ 5 ] ;
flotter tableau flottant [ 5 ] ;
} ;
int principal ( ) {
TableauUnion tableauUnion ;
pour ( int je = 0 ; je < 5 ; ++ je ) {
tableauUnion. tableauint [ je ] = je * 2 ;
}
cout << « Tableau international : » ;
pour ( int je = 0 ; je < 5 ; ++ je ) {
cout << ' ' << tableauUnion. tableauint [ je ] ;
}
cout << fin ;
pour ( int je = 0 ; je < 5 ; ++ je ) {
tableauUnion. tableau flottant [ je ] = je * 1,5f ;
}
cout << « Tableau flottant : » ;
pour ( int je = 0 ; je < 5 ; ++ je ) {
cout << ' ' << tableauUnion. tableau flottant [ je ] ;
}
cout << fin ;
retour 0 ;
}
Dans cet extrait de code C++, nous utilisons une union nommée « MyUnion » qui incorpore trois données membres différentes : un entier (intValue), un nombre à virgule flottante (floatValue) et un caractère (charValue). Un seul de ces membres peut être actif à un moment donné en raison de la capacité d’un syndicat à partager un espace mémoire.
Au sein de la fonction « main », nous déclarons une instance de l’union qui est « myUnion ». Tout d’abord, nous définissons la valeur du membre entier sur 42 et utilisons « cout » pour l’imprimer. Par la suite, nous attribuons la valeur à virgule flottante de 3,14 au membre « floatValue » et l'imprimons. Enfin, nous attribuons le caractère « A » au membre « charValue » et l'imprimons. Il est essentiel de se rappeler que puisque tous les membres du syndicat partagent le même emplacement mémoire, la modification d’un membre peut avoir un impact sur les valeurs des autres membres. Le code se termine en renvoyant 0, ce qui signifie une exécution réussie.
Exemple 2 : Union avec Struct
Une structure est un type de données en C++ que les utilisateurs peuvent créer pour combiner les variables de différents types sous un nom unifié. La combinaison d'une union avec une structure peut être utile lorsque nous souhaitons créer une structure de données pouvant contenir différents types de données, et chaque type est associé à un champ spécifique. Ce couplage permet le développement de structures de données complexes présentant des représentations diverses.
Voici un exemple d’utilisation d’une union dans une structure en C++ :
#includeen utilisant l'espace de noms std ;
structurer Indiquer {
int s1 ;
int s2 ;
} ;
syndicat Forme {
int côtés ;
flotter rayon ;
Centre des points ;
} ;
int principal ( ) {
Forme de forme ;
forme. côtés = 5 ;
cout << 'Côtés: ' << forme. côtés << fin ;
forme. rayon = 6,0f ;
cout << « Rayon : » << forme. rayon << fin ;
forme. centre = { dix , vingt } ;
cout << 'Centre: (' << forme. centre . s1 << ', ' << forme. centre . s2 << ')' << fin ;
retour 0 ;
}
Dans ce code, nous définissons un programme C++ qui utilise une union et une structure pour représenter différents aspects d'une forme géométrique. Tout d’abord, nous déclarons une structure « Point » composée de deux membres entiers, « s1 » et « s2 », qui représentent les coordonnées d’un point dans un espace 2D. Ensuite, nous définissons une « union » nommée « Forme » qui se compose de trois membres : un entier « côtés », une virgule flottante « rayon » et une structure « Point » nommée « centre ». Passant à la fonction « main », nous instancions un objet « Shape » nommé « shape ». Nous démontrons ensuite la polyvalence du syndicat en attribuant des valeurs à ses différents membres. Initialement, nous fixons le nombre de côtés à 5 et imprimons le résultat. Ensuite, nous attribuons un rayon de 6,0 à la forme et générons le rayon. Enfin, nous attribuons un point central avec les coordonnées (10, 20) à la forme et imprimons les coordonnées du centre.
Exemple 3 : Union avec Enum
En C++, les énumérations, communément appelées énumérations, servent à définir une collection de constantes intégrales nommées. La combinaison d'énumérations avec des unions peut être utile dans les scénarios où nous souhaitons représenter une variable qui peut prendre différents types, chacun associé à une valeur d'énumération spécifique.
Voici un exemple :
#includeen utilisant l'espace de noms std ;
énumération Type de données {
ENTIER ,
FLOTTER ,
CARBONISER
} ;
syndicat Valeur des données {
int valeurint ;
flotter valeur flottante ;
carboniser charValue ;
} ;
structurer Données {
Type de données ;
Valeur DataValue ;
} ;
int principal ( )
{
Données données1 , données2 , données3 ;
données1. taper = ENTIER ;
données1. valeur . valeurint = 42 ;
données2. taper = FLOTTER ;
données2. valeur . valeur flottante = 3.14f ;
données3. taper = CARBONISER ;
données3. valeur . charValue = 'UN' ;
cout << 'Données 1 : ' << données1. valeur . valeurint << fin ;
cout << 'Données 2 : ' << données2. valeur . valeur flottante << fin ;
cout << 'Données 3 : ' << données3. valeur . charValue << fin ;
retour 0 ;
}
Pour cet exemple, nous avons un programme qui utilise des énumérations, des unions et des structures pour créer une structure de données flexible capable de contenir différents types de valeurs. L'énumération « DataType » est définie pour représenter trois types de données fondamentaux : INTEGER, FLOAT et CHAR. L'énumération améliore la lisibilité et la maintenabilité du code en offrant un ensemble de constantes intégrales nommées.
Ensuite, nous créons une union appelée « DataValue » avec trois membres : « charValue » de type char, « floatValue » de type float et « intValue » de type int. Avec une union, ces membres partagent un emplacement mémoire commun qui permet à l’union d’accueillir de manière interchangeable les valeurs de types distincts. La structure « Data » est ensuite créée et composée de deux membres : un énumérateur « DataType » nommé « type » et une union « DataValue » nommée « value ». Cette structure nous permet d'associer un type de données à sa valeur correspondante, fournissant une représentation structurée.
Dans la fonction « main », nous instancions trois instances de la structure « Data » : « data1 », « data2 » et « data3 ». Nous attribuons les valeurs à ces instances en spécifiant le type de données et en définissant la valeur appropriée au sein de l'union. Par exemple, « data1 » se voit attribuer un type INTEGER avec une valeur de 42. Enfin, nous utilisons les instructions « cout » pour imprimer les valeurs stockées dans chaque instance « Data ». Le programme génère la valeur entière de « data1 », la valeur à virgule flottante de « data2 » et la valeur de caractère de « data3 ».
Cet exemple illustre comment la combinaison des énumérations, des unions et des structures peut être utilisée pour créer une représentation de données polyvalente et sécurisée en C++.
Conclusion
Les unions C++ fournissent un mécanisme puissant et flexible pour gérer les divers types de données au sein d’un seul espace mémoire. Les exemples illustrés dans cet article mettent en évidence l’adaptabilité et l’efficacité des syndicats face à une gamme de scénarios. Depuis les utilisations fondamentales qui démontrent l'interchangeabilité des types de données jusqu'aux applications plus complexes impliquant des structures et des énumérations, ces exemples soulignent l'efficacité et l'adaptabilité que les unions apportent à la programmation C++.