Sintaxă:
O unire este un tip care este definit de utilizator, permițând stocarea diferitelor tipuri de date într-o locație de memorie partajată. Utilizarea unei uniuni urmează o sintaxă care este identică cu o structură.
Sintaxa fundamentală este următoarea:
uniune UnionName {
// Declarații ale membrilor
DataType1 membru1 ;
DataType2 membru2 ;
//...
} ;
Aici, „UnionName” servește ca identificator pentru uniune care oferă un nume unic pentru a face referire la acest tip specific definit de utilizator. Tipurile de date ale membrilor de sindicat sunt notate ca „DataType1”, „DataType2” și așa mai departe. Aceste tipuri de date semnifică tipurile variate de informații care pot fi stocate în cadrul uniunii. Fiecare membru din cadrul uniunii, desemnat prin nume precum „membru1”, „membru 2”, etc., reprezintă o bucată de date distinctă.
Înțelegem acum sintaxa de bază. Să folosim acum câteva exemple pentru a înțelege mai bine acest lucru.
Exemplul 1: Utilizarea de bază a uniunii
Primul exemplu ilustrează utilizarea de bază a uniunilor în C++, arătând modul în care acestea permit partajarea spațiului de memorie între diferite tipuri de date într-o singură structură.
Iată un exemplu:
#include
folosind namespace std ;
uniune ArrayUnion {
int intArray [ 5 ] ;
pluti floatArray [ 5 ] ;
} ;
int principal ( ) {
ArrayUnion arrayUnion ;
pentru ( int i = 0 ; i < 5 ; ++ i ) {
arrayUnion. intArray [ i ] = i * 2 ;
}
cout << „Matrice int:” ;
pentru ( int i = 0 ; i < 5 ; ++ i ) {
cout << ' ' << arrayUnion. intArray [ i ] ;
}
cout << endl ;
pentru ( int i = 0 ; i < 5 ; ++ i ) {
arrayUnion. floatArray [ i ] = i * 1.5f ;
}
cout << „Matrice flotantă:” ;
pentru ( int i = 0 ; i < 5 ; ++ i ) {
cout << ' ' << arrayUnion. floatArray [ i ] ;
}
cout << endl ;
întoarcere 0 ;
}
În acest fragment de cod C++, utilizăm o uniune numită „MyUnion” care încorporează trei membri de date diferiți: un număr întreg (intValue), un număr în virgulă mobilă (floatValue) și un caracter (charValue). Doar unul dintre acești membri poate fi activ la un moment dat datorită capacității sindicatului de a partaja un spațiu de memorie.
În cadrul funcției „principal”, declarăm o instanță a uniunii care este „myUnion”. Mai întâi, setăm valoarea membrului întreg la 42 și folosim „cout” pentru a-l imprima. Ulterior, atribuim valoarea în virgulă mobilă de 3,14 membrului „floatValue” și o imprimăm. În cele din urmă, atribuim caracterul „A” membrului „charValue” și îl imprimăm. Este esențial să ne amintim că, deoarece toți membrii de sindicat au aceeași locație de memorie, modificarea unui membru poate avea un impact asupra valorilor altor membri. Codul se încheie prin returnarea 0, ceea ce înseamnă o execuție cu succes.
Exemplul 2: Unirea cu Struct
O structură este un tip de date în C++ pe care utilizatorii le pot crea pentru a combina variabilele de diferite tipuri sub un nume unificat. Combinarea unei uniuni cu o structură poate fi utilă atunci când dorim să creăm o structură de date care poate conține diferite tipuri de date, iar fiecare tip este asociat unui anumit câmp. Această împerechere permite dezvoltarea unor structuri complexe de date cu reprezentări diverse.
Iată un exemplu de utilizare a unei uniuni în cadrul unei structuri în C++:
#includefolosind namespace std ;
struct Punct {
int s1 ;
int s2 ;
} ;
uniune Formă {
int laturi ;
pluti rază ;
Centru punct ;
} ;
int principal ( ) {
Forma formă ;
formă. laturi = 5 ;
cout << 'Laturi:' << formă. laturi << endl ;
formă. rază = 6.0f ;
cout << 'Raza:' << formă. rază << endl ;
formă. centru = { 10 , douăzeci } ;
cout << 'Centru: (' << formă. centru . s1 << ', ' << formă. centru . s2 << ')' << endl ;
întoarcere 0 ;
}
În acest cod, definim un program C++ care utilizează o unire și o structură pentru a reprezenta diferite aspecte ale unei forme geometrice. În primul rând, declarăm o structură „Punct” care constă din doi membri întregi, „s1” și „s2”, care reprezintă coordonatele unui punct într-un spațiu 2D. Apoi, definim o „uniune” numită „Formă” care constă din trei membri: un întreg „laturi”, o virgulă mobilă „rază” și o structură „Punct” numită „centru”. Trecând la funcția „principală”, instanțiăm un obiect „Shape” numit „shape”. Demonstrăm apoi versatilitatea uniunii prin atribuirea de valori diferiților săi membri. Inițial, setăm numărul de fețe la 5 și imprimăm rezultatul. Apoi, atribuim o rază de 6,0 formei și ieșim raza. În cele din urmă, atribuim un punct central cu coordonate (10, 20) formei și imprimăm coordonatele centrului.
Exemplul 3: Unirea cu Enum
În C++, enumerările, denumite în mod obișnuit enums, servesc scopului de a defini o colecție de constante denumite integrale. Combinarea enumărilor cu uniuni poate fi utilă în scenariile în care dorim să reprezentăm o variabilă care poate lua diferite tipuri, fiecare asociat cu o anumită valoare enumerare.
Iată un exemplu:
#includefolosind namespace std ;
enumerare DataType {
ÎNTREG ,
PLUTI ,
CHAR
} ;
uniune DataValue {
int intValue ;
pluti floatValue ;
char charValue ;
} ;
struct Date {
Tip DataType ;
Valoare DataValue ;
} ;
int principal ( )
{
Date de date 1 , date2 , date3 ;
date1. tip = ÎNTREG ;
date1. valoare . intValue = 42 ;
date2. tip = PLUTI ;
date2. valoare . floatValue = 3.14f ;
date3. tip = CHAR ;
date3. valoare . charValue = 'A' ;
cout << „Date 1:” << date1. valoare . intValue << endl ;
cout << 'Date 2:' << date2. valoare . floatValue << endl ;
cout << 'Date 3:' << date3. valoare . charValue << endl ;
întoarcere 0 ;
}
Pentru acest exemplu, avem un program care utilizează enumerari, uniuni și structuri pentru a crea o structură de date flexibilă, capabilă să dețină diferite tipuri de valori. Enumerația „DataType” este definită pentru a reprezenta trei tipuri de date fundamentale: INTEGER, FLOAT și CHAR. Enumerația îmbunătățește lizibilitatea și mentenabilitatea codului, oferind un set de constante integrale numite.
Apoi, facem o uniune numită „DataValue” cu trei membri: „charValue” de tip char, „floatValue” de tip float și „intValue” de tip int. Cu o uniune, acești membri împărtășesc o locație de memorie comună, care permite uniunii să găzduiască în mod interschimbabil valorile unor tipuri distincte. Este apoi creată structura „Date” care constă din doi membri: un enumerator „DataType” numit „type” și o uniune „DataValue” numită „value”. Această structură ne permite să asociem un tip de date cu valoarea corespunzătoare, oferind o reprezentare structurată.
În funcția „principală”, instanțiăm trei instanțe ale structurii „Date”: „data1”, „data2” și „data3”. Atribuim valorile acestor instanțe specificând tipul de date și setând valoarea corespunzătoare în cadrul uniunii. De exemplu, „data1” este atribuit cu un tip INTEGER cu o valoare de 42. În cele din urmă, folosim instrucțiunile „cout” pentru a tipări valorile care sunt stocate în fiecare instanță „Date”. Programul emite valoarea întreagă a „data1”, valoarea în virgulă mobilă a „data2” și valoarea caracterului „data3”.
Acest exemplu ilustrează modul în care combinarea enumărilor, uniunilor și structurilor poate fi folosită pentru a crea o reprezentare de date versatilă și sigură pentru tip în C++.
Concluzie
Uniunile C++ oferă un mecanism puternic și flexibil pentru gestionarea diferitelor tipuri de date într-un singur spațiu de memorie. Exemplele care sunt ilustrate în acest articol evidențiază adaptabilitatea și eficacitatea sindicatelor în abordarea unei game de scenarii. De la utilizările fundamentale care demonstrează interschimbabilitatea tipurilor de date până la aplicații mai complexe care implică structuri și enumerari, aceste exemple subliniază eficiența și adaptabilitatea pe care uniunile le aduc programării C++.