Unie kan worden gedefinieerd als een door de gebruiker gedefinieerd gegevenstype dat een verzameling verschillende variabelen van verschillende gegevenstypen op dezelfde geheugenlocatie is. De unie kan ook worden gedefinieerd als veel leden, maar slechts één lid kan op een bepaald moment een waarde bevatten.

Union is een door de gebruiker gedefinieerd gegevenstype, maar in tegenstelling tot structuren delen ze dezelfde geheugenlocatie.

adjunct-commissaris van politie

Laten we dit begrijpen aan de hand van een voorbeeld.

 struct abc { int a; char b; } 

De bovenstaande code is de door de gebruiker gedefinieerde structuur die uit twee leden bestaat, d.w.z. 'a' van het type int en 'b' van type karakter . Toen we de adressen van 'a' en 'b' controleerden, ontdekten we dat hun adressen verschillend zijn. Daarom concluderen we dat de leden in de structuur niet dezelfde geheugenlocatie delen.

Toen we de unie definieerden, ontdekten we dat unie op dezelfde manier werd gedefinieerd als de structuur, maar het verschil is dat het union-trefwoord wordt gebruikt voor het definiëren van het union-gegevenstype, terwijl het struct-trefwoord wordt gebruikt voor het definiëren van de structuur. De unie bevat de gegevensleden, dat wil zeggen 'a' en 'b'. Toen we de adressen van beide variabelen controleerden, ontdekten we dat beide dezelfde adressen hebben. Het betekent dat de vakbondsleden dezelfde geheugenlocatie delen.

Laten we eens kijken naar de grafische weergave van de geheugentoewijzing.

De onderstaande afbeelding toont de grafische weergave van de constructie. De structuur bestaat uit twee leden; d.w.z. de ene is van het integer-type en de andere van het tekentype. Omdat 1 blok gelijk is aan 1 byte; daarom krijgt de variabele 'a' vier geheugenblokken toegewezen, terwijl de variabele 'b' één geheugenblok krijgt toegewezen.

Onderstaande figuur toont de afbeelding van de vakbondsleden. Beide variabelen delen dezelfde geheugenlocatie en hebben hetzelfde initiële adres.

In de vakbond delen de leden de geheugenlocatie. Als we proberen wijzigingen aan te brengen in een van de leden, zal dit ook worden weerspiegeld in de andere leden. Laten we dit concept begrijpen aan de hand van een voorbeeld.

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

In de bovenstaande code heeft vakbond twee leden, namelijk 'a' en 'b'. De 'var' is een variabele van het type union abc. In de voornaamst() Bij de methode wijzen we de 66 toe aan de variabele 'a', dus var.a zal 66 op het scherm afdrukken. Omdat zowel 'a' als 'b' de geheugenlocatie delen, var.b zal afdrukken ' B ' (ASCII-code van 66).

Beslissen over de omvang van de vakbond

De omvang van de vakbond is gebaseerd op de omvang van het grootste lid van de vakbond.

Laten we het begrijpen aan de hand van een voorbeeld.

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

Zoals we weten is de grootte van int 4 bytes, de grootte van char 1 byte, de grootte van float 4 bytes en de grootte van double 8 bytes. Omdat de dubbele variabele het grootste geheugen van alle vier variabelen in beslag neemt, worden er in totaal 8 bytes aan het geheugen toegewezen. Daarom zou de uitvoer van het bovenstaande programma 8 bytes zijn.

Toegang tot leden van de vakbond met behulp van pointers

We hebben toegang tot de leden van de vakbond via verwijzingen met behulp van de (->) pijloperator.

Laten we het begrijpen aan de hand van een voorbeeld.

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

In de bovenstaande code hebben we een pointervariabele gemaakt, d.w.z. *ptr, die het adres van de var-variabele opslaat. Nu heeft ptr toegang tot de variabele 'a' door de operator (->) te gebruiken. Daarom zou de uitvoer van de bovenstaande code 90 zijn.

alfabet naar nummer

Waarom hebben we C-vakbonden nodig?

Beschouw een voorbeeld om de noodzaak van C-vakbonden te begrijpen. Laten we een winkel bekijken die twee items heeft:

• Boeken
• Overhemden

Winkeleigenaren willen de records van de bovengenoemde twee items samen met de relevante informatie opslaan. Boeken bevatten bijvoorbeeld Titel, Auteur, aantal pagina's, prijs, en Shirts bevatten Kleur, ontwerp, maat en prijs. De eigenschap 'prijs' is gebruikelijk in beide artikelen. De winkeleigenaar wil de eigendommen opslaan en vervolgens hoe hij/zij de records zal opslaan.

Aanvankelijk besloten ze de records op te slaan in een structuur zoals hieronder weergegeven:

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

De bovenstaande structuur bestaat uit alle items die de winkeleigenaar wil opslaan. De bovenstaande structuur is volledig bruikbaar, maar de prijs is gemeenschappelijk eigendom van zowel de artikelen als de rest van de artikelen zijn individueel. De eigenschappen zoals prijs, *titel, *auteur en aantal_pagina's horen bij Boeken, terwijl kleur, maat en *ontwerp bij Shirt horen.

Laten we eens kijken hoe we toegang kunnen krijgen tot de leden van de structuur .

aardnoot versus pinda

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

In de bovenstaande code hebben we een variabele van type gemaakt winkel . We hebben de waarden toegewezen aan de variabelen titel, auteur, aantal_pagina's en prijs, maar de boekvariabele bezit niet de eigenschappen zoals grootte, kleur en ontwerp. Het is dus geheugenverspilling. De grootte van de bovenstaande structuur zou 44 bytes zijn.

We kunnen veel ruimte besparen als we vakbonden gebruiken.

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

In de bovenstaande code hebben we een variabele van het type store gemaakt. Omdat we de vakbonden in de bovenstaande code hebben gebruikt, zou het grootste geheugen dat door de variabele wordt ingenomen, in aanmerking worden genomen voor de geheugentoewijzing. De uitvoer van het bovenstaande programma is 32 bytes. In het geval van structuren hebben we 44 bytes verkregen, terwijl in het geval van unies de verkregen grootte 44 bytes is. Daarom is 44 bytes groter dan 32 bytes, wat veel geheugenruimte bespaart.