Unione può essere definito come un tipo di dati definito dall'utente che è una raccolta di diverse variabili di diversi tipi di dati nella stessa posizione di memoria. L'unione può anche essere definita come molti membri, ma solo un membro può contenere un valore in un determinato momento.

L'unione è un tipo di dati definito dall'utente ma, a differenza delle strutture, condivide la stessa posizione di memoria.

Capiamolo attraverso un esempio.

 struct abc { int a; char b; } 

Il codice precedente è la struttura definita dall'utente composta da due membri, ovvero 'a' di tipo int e 'b' di tipo carattere . Quando controlliamo gli indirizzi di 'a' e 'b', abbiamo scoperto che i loro indirizzi sono diversi. Pertanto, concludiamo che i membri della struttura non condividono la stessa posizione di memoria.

Quando definiamo l'unione, abbiamo scoperto che l'unione è definita nello stesso modo in cui viene definita la struttura, ma la differenza è che la parola chiave union viene utilizzata per definire il tipo di dati dell'unione, mentre la parola chiave struct viene utilizzata per definire la struttura. L'unione contiene i membri dati, ovvero 'a' e 'b', quando controlliamo gli indirizzi di entrambe le variabili, scopriamo che entrambe hanno gli stessi indirizzi. Significa che i membri del sindacato condividono la stessa locazione di memoria.

Diamo un'occhiata alla rappresentazione pittorica dell'allocazione della memoria.

La figura sottostante mostra la rappresentazione pittorica della struttura. La struttura è composta da due membri; cioè uno è di tipo intero e l'altro è di tipo carattere. Poiché 1 blocco equivale a 1 byte; pertanto, alla variabile 'a' verranno assegnati 4 blocchi di memoria mentre alla variabile 'b' verrà assegnato 1 blocco di memoria.

La figura seguente mostra la rappresentazione pittorica degli iscritti al sindacato. Entrambe le variabili condividono la stessa posizione di memoria e hanno lo stesso indirizzo iniziale.

In unione, i membri condivideranno la posizione della memoria. Se proviamo ad apportare modifiche a uno qualsiasi dei membri, ciò si rifletterà anche sull'altro membro. Cerchiamo di comprendere questo concetto attraverso un esempio.

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

Nel codice precedente, l'unione ha due membri, ovvero 'a' e 'b'. La 'var' è una variabile di tipo union abc. Nel principale() metodo, assegniamo il 66 alla variabile 'a', quindi var.a stamperà 66 sullo schermo. Poiché sia ​​'a' che 'b' condividono la posizione di memoria, var.b stamperà ' B ' (codice ASCII di 66).

Decidere la dimensione del sindacato

La dimensione del sindacato si basa sulla dimensione del membro più grande del sindacato.

Capiamo attraverso un esempio.

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

Come sappiamo, la dimensione di int è 4 byte, la dimensione di char è 1 byte, la dimensione di float è 4 byte e la dimensione di double è 8 byte. Poiché la doppia variabile occupa la memoria più grande tra tutte e quattro le variabili, nella memoria verranno allocati in totale 8 byte. Pertanto, l'output del programma precedente sarebbe di 8 byte.

Accesso ai membri dell'unione tramite puntatori

Possiamo accedere ai membri dell'unione tramite puntatori utilizzando l'operatore freccia (->).

Capiamo attraverso un esempio.

 #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; } 

Nel codice precedente, abbiamo creato una variabile puntatore, ovvero *ptr, che memorizza l'indirizzo della variabile var. Ora ptr può accedere alla variabile 'a' utilizzando l'operatore (->). Quindi l'output del codice sopra sarebbe 90.

Perché abbiamo bisogno dei sindacati C?

Consideriamo un esempio per comprendere la necessità delle unioni C. Consideriamo un negozio che ha due articoli:

• Libri
• Camicie

I proprietari dei negozi desiderano archiviare i record dei due articoli sopra menzionati insieme alle informazioni pertinenti. Ad esempio, i libri includono titolo, autore, numero di pagine, prezzo e le magliette includono colore, design, dimensione e prezzo. La proprietà 'prezzo' è comune a entrambi gli elementi. Il proprietario del negozio desidera archiviare le proprietà, quindi come archivierà i record.

Inizialmente, hanno deciso di archiviare i record in una struttura come mostrato di seguito:

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

La struttura di cui sopra è composta da tutti gli articoli che il proprietario del negozio desidera archiviare. La struttura di cui sopra è completamente utilizzabile, ma il prezzo è di proprietà comune in entrambi gli articoli e il resto degli articoli è individuale. Le proprietà come prezzo, *titolo, *autore e numero_pagine appartengono a Libri mentre colore, taglia, *design appartengono a Camicia.

la classe astratta può avere un costruttore

Vediamo come possiamo accedere ai membri della struttura .

 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; } 

Nel codice precedente, abbiamo creato una variabile di tipo negozio . Abbiamo assegnato i valori alle variabili titolo, autore, numero_pagine, prezzo ma la variabile libro non possiede proprietà come dimensione, colore e design. Quindi è uno spreco di memoria. La dimensione della struttura precedente sarebbe di 44 byte.

Possiamo risparmiare molto spazio se utilizziamo i sindacati.

 #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; } 

Nel codice precedente, abbiamo creato una variabile di tipo store. Poiché abbiamo utilizzato le unioni nel codice precedente, per l'allocazione della memoria verrà considerata la memoria più grande occupata dalla variabile. L'output del programma sopra è di 32 byte. Nel caso delle strutture abbiamo ottenuto 44 byte, mentre nel caso delle unioni la dimensione ottenuta è di 44 byte. Pertanto, 44 ​​byte sono maggiori di 32 byte, risparmiando molto spazio di memoria.