Sintassi:
Un'unione è un tipo definito dall'utente, che consente l'archiviazione di diversi tipi di dati all'interno di una posizione di memoria condivisa. L'uso di un'unione segue una sintassi identica a una struttura.
La sintassi fondamentale è la seguente:
unione NomeUnione {
// Dichiarazioni dei membri
Membro DataType11 ;
Membro DataType22 ;
//...
} ;
In questo caso, 'UnionName' funge da identificatore per l'unione che fornisce un nome univoco per fare riferimento a questo specifico tipo definito dall'utente. I tipi di dati dei membri dell'unione sono indicati come 'DataType1', 'DataType2' e così via. Questi tipi di dati indicano i vari tipi di informazioni che possono essere archiviati all'interno dell'unione. Ogni membro all'interno dell'unione, designato con nomi come “membro1”, “membro2”, ecc., rappresenta un dato distinto.
Ora comprendiamo la sintassi di base. Usiamo ora alcuni esempi per capirlo meglio.
Esempio 1: utilizzo di base dell'unione
Il primo esempio illustra l'utilizzo di base delle unioni in C++, mostrando come consentono la condivisione dello spazio di memoria tra diversi tipi di dati all'interno di un'unica struttura.
Ecco un esempio:
#include
utilizzando lo spazio dei nomi std ;
unione ArrayUnion {
int intArray [ 5 ] ;
galleggiante floatArray [ 5 ] ;
} ;
int principale ( ) {
ArrayUnion arrayUnion ;
per ( int io = 0 ; io < 5 ; ++ io ) {
arrayUnion. intArray [ io ] = io * 2 ;
}
cout << 'Matrice Int:' ;
per ( int io = 0 ; io < 5 ; ++ io ) {
cout << ' ' << arrayUnion. intArray [ io ] ;
}
cout << fine ;
per ( int io = 0 ; io < 5 ; ++ io ) {
arrayUnion. floatArray [ io ] = io * 1,5f ;
}
cout << 'Matrice mobile:' ;
per ( int io = 0 ; io < 5 ; ++ io ) {
cout << ' ' << arrayUnion. floatArray [ io ] ;
}
cout << fine ;
ritorno 0 ;
}
In questo frammento di codice C++ utilizziamo un'unione denominata 'MyUnion' che incorpora tre diversi membri dati: un numero intero (intValue), un numero a virgola mobile (floatValue) e un carattere (charValue). Solo uno di questi membri può essere attivo in un dato momento a causa della capacità di un sindacato di condividere uno spazio di memoria.
All'interno della funzione “main”, dichiariamo un'istanza dell'unione che è “myUnion”. Innanzitutto, impostiamo il valore del membro intero su 42 e utilizziamo 'cout' per stamparlo. Successivamente assegniamo il valore in virgola mobile 3.14 al membro “floatValue” e lo stampiamo. Infine, assegniamo il carattere “A” al membro “charValue” e lo stampiamo. È essenziale ricordare che, poiché tutti i membri del sindacato condividono la stessa posizione di memoria, alterare un membro può avere un impatto sui valori degli altri membri. Il codice si conclude restituendo 0 che indica un'esecuzione riuscita.
Esempio 2: Unione con Struct
Una struttura è un tipo di dati in C++ che gli utenti possono creare per combinare variabili di vario tipo sotto un unico nome unificato. Combinare un'unione con una struttura può essere utile quando vogliamo creare una struttura dati che possa contenere diversi tipi di dati e ogni tipo è associato a un campo specifico. Questo abbinamento consente lo sviluppo di strutture dati complesse con rappresentazioni diverse.
Ecco un esempio di utilizzo di un'unione all'interno di una struttura in C++:
#includeutilizzando lo spazio dei nomi std ;
struttura Punto {
int s1 ;
int s2 ;
} ;
unione Forma {
int lati ;
galleggiante raggio ;
Centro del punto ;
} ;
int principale ( ) {
Forma forma ;
forma. lati = 5 ;
cout << 'Lati: ' << forma. lati << fine ;
forma. raggio = 6.0f ;
cout << 'Raggio: ' << forma. raggio << fine ;
forma. centro = { 10 , venti } ;
cout << 'Centro: (' << forma. centro . s1 << ', ' << forma. centro . s2 << ')' << fine ;
ritorno 0 ;
}
In questo codice definiamo un programma C++ che utilizza un'unione e una struttura per rappresentare diversi aspetti di una forma geometrica. Innanzitutto, dichiariamo una struttura “Point” composta da due membri interi, “s1” e “s2”, che rappresentano le coordinate di un punto in uno spazio 2D. Quindi, definiamo una 'unione' denominata 'Shape' composta da tre membri: un intero 'lati', un punto mobile 'raggio' e una struttura 'Punto' denominata 'centro'. Passando alla funzione “main”, istanziamo un oggetto “Shape” denominato “shape”. Dimostreremo poi la versatilità del sindacato assegnando valori ai suoi diversi membri. Inizialmente impostiamo il numero di lati su 5 e stampiamo il risultato. Successivamente, assegniamo un raggio di 6,0 alla forma e restituiamo il raggio. Infine, assegniamo un punto centrale con coordinate (10, 20) alla forma e stampiamo le coordinate del centro.
Esempio 3: Unione con Enum
In C++, le enumerazioni, comunemente denominate enumerazioni, hanno lo scopo di definire una raccolta di costanti integrali denominate. Combinare enum con unioni può essere utile negli scenari in cui vogliamo rappresentare una variabile che può assumere diversi tipi, ciascuno associato a uno specifico valore enum.
Ecco un esempio:
#includeutilizzando lo spazio dei nomi std ;
enum Tipo di dati {
NUMERO INTERO ,
GALLEGGIANTE ,
CAR
} ;
unione ValoreDati {
int intValore ;
galleggiante floatValue ;
car charValue ;
} ;
struttura Dati {
Tipo di tipo dati ;
Valore DataValue ;
} ;
int principale ( )
{
Dati dati1 , dati2 , dati3 ;
dati1. tipo = NUMERO INTERO ;
dati1. valore . intValore = 42 ;
dati2. tipo = GALLEGGIANTE ;
dati2. valore . floatValue = 3.14f ;
dati3. tipo = CAR ;
dati3. valore . charValue = 'UN' ;
cout << 'Dati 1: ' << dati1. valore . intValore << fine ;
cout << 'Dati 2: ' << dati2. valore . floatValue << fine ;
cout << 'Dati 3: ' << dati3. valore . charValue << fine ;
ritorno 0 ;
}
Per questo esempio, abbiamo un programma che utilizza enumerazioni, unioni e strutture per creare una struttura dati flessibile in grado di contenere diversi tipi di valori. L'enumerazione 'DataType' è definita per rappresentare tre tipi di dati fondamentali: INTEGER, FLOAT e CHAR. L'enumerazione migliora la leggibilità e la manutenibilità del codice offrendo un insieme di costanti integrali denominate.
Quindi, creiamo un'unione chiamata 'DataValue' con tre membri: 'charValue' di tipo char, 'floatValue' di tipo float e 'intValue' di tipo int. Con un'unione, questi membri condividono una posizione di memoria comune che consente all'unione di accogliere in modo intercambiabile i valori di tipi distinti. Viene quindi creata la struttura 'Data' composta da due membri: un enumeratore 'DataType' denominato 'tipo' e un'unione 'DataValue' denominata 'valore'. Questa struttura ci permette di associare un tipo di dato al suo valore corrispondente, fornendo una rappresentazione strutturata.
Nella funzione “main”, istanziamo tre istanze della struttura “Data”: “data1”, “data2” e “data3”. Assegniamo i valori a queste istanze specificando il tipo di dati e impostando il valore appropriato all'interno dell'unione. Ad esempio, a 'data1' viene assegnato un tipo INTEGER con un valore di 42. Infine, utilizziamo le istruzioni 'cout' per stampare i valori memorizzati in ciascuna istanza 'Data'. Il programma emette il valore intero di “data1”, il valore in virgola mobile di “data2” e il valore del carattere di “data3”.
Questo esempio illustra come è possibile utilizzare la combinazione di enumerazioni, unioni e strutture per creare una rappresentazione dei dati versatile e indipendente dai tipi in C++.
Conclusione
Le unioni C++ forniscono un meccanismo potente e flessibile per la gestione dei diversi tipi di dati all'interno di un singolo spazio di memoria. I casi illustrati in questo articolo evidenziano l’adattabilità e l’efficacia dei sindacati nell’affrontare una serie di scenari. Dagli usi fondamentali che dimostrano l'intercambiabilità dei tipi di dati alle applicazioni più complesse che coinvolgono strutture ed enumerazioni, questi esempi sottolineano l'efficienza e l'adattabilità che le unioni apportano alla programmazione C++.