Unió felhasználó által definiált adattípusként definiálható, amely különböző adattípusok különböző változóinak gyűjteménye ugyanazon a memóriahelyen. Az unió több tagként is meghatározható, de egy adott időpontban csak egy tag tartalmazhat értéket.

Az Union egy felhasználó által meghatározott adattípus, de a struktúrákkal ellentétben ugyanazon a memóriahelyen osztoznak.

Értsük meg ezt egy példán keresztül.

 struct abc { int a; char b; } 

A fenti kód a felhasználó által definiált struktúra, amely két tagból áll, azaz „a” típusú int és 'b' típusú karakter . Amikor ellenőriztük az „a” és „b” címét, azt találtuk, hogy a címeik különböznek. Ezért arra a következtetésre jutottunk, hogy a struktúra tagjai nem ugyanazon a memóriahelyen osztoznak.

Az unió definiálásakor azt találtuk, hogy az unió ugyanúgy van definiálva, mint a struktúra, de a különbség az, hogy az union kulcsszó az unió adattípusának meghatározására szolgál, míg a struct kulcsszó a struktúra meghatározására. Az unió tartalmazza az adattagokat, azaz 'a' és 'b'-t, amikor mindkét változó címét ellenőriztük, akkor azt találtuk, hogy mindkettőnek ugyanaz a címe. Ez azt jelenti, hogy a szakszervezeti tagok ugyanazon a memóriahelyen osztoznak.

Nézzük meg a memóriafoglalás képi ábrázolását.

Az alábbi ábra a szerkezet képi ábrázolását mutatja. A szerkezet két tagú; azaz az egyik egész, a másik karakter típusú. Mivel 1 blokk egyenlő 1 bájttal; ezért az 'a' változó 4 memóriablokkot, míg a 'b' változó 1 memóriablokkot foglal le.

Az alábbi ábrán a szakszervezeti tagok képi ábrázolása látható. Mindkét változó ugyanazt a memóriahelyet használja, és azonos kezdeti címmel rendelkezik.

Szakszervezetben a tagok megosztják a memóriahelyet. Ha valamelyik tagon megpróbálunk változtatni, akkor az a másik tagon is megjelenik. Értsük meg ezt a fogalmat egy példán keresztül.

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

A fenti kódexben a szakszervezetnek két tagja van, azaz „a” és „b”. A 'var' egy union abc típusú változó. Ban,-ben fő() módszerrel a 66-ot az 'a' változóhoz rendeljük, így a var.a 66-ot nyomtat a képernyőre. Mivel az „a” és „b” is megosztja a memóriahelyet, var.b nyomtatni fog B (66-os ascii-kód).

python ill

A szakszervezet méretének meghatározása

A szakszervezet mérete a szakszervezet legnagyobb tagjának méretén alapul.

Értsük meg egy példán keresztül.

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

Mint tudjuk, az int mérete 4 bájt, a char mérete 1 bájt, a float mérete 4 bájt, a double mérete pedig 8 bájt. Mivel a kettős változó foglalja el a legnagyobb memóriát mind a négy változó közül, így összesen 8 bájt lesz lefoglalva a memóriában. Ezért a fenti program kimenete 8 bájt lenne.

A szakszervezet tagjainak elérése mutatók segítségével

A (->) nyíl operátor segítségével pointereken keresztül érhetjük el a szakszervezet tagjait.

Értsük meg egy példán keresztül.

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

A fenti kódban létrehoztunk egy mutatóváltozót, azaz a *ptr-t, amely a var változó címét tárolja. Most a ptr elérheti az 'a' változót a (->) operátor használatával. Ezért a fenti kód kimenete 90 lenne.

Miért van szükségünk C szakszervezetekre?

Vegyünk egy példát, hogy megértsük a C uniók szükségességét. Tekintsünk egy üzletet, amelyben két termék található:

• Könyvek
• Ingek

Az üzlettulajdonosok a fent említett két cikk nyilvántartását kívánják tárolni a vonatkozó információkkal együtt. Például a Könyvek tartalmazzák a címet, a szerzőt, az oldalak számát, az árat, a pólók pedig a színt, a dizájnt, a méretet és az árat. Az „ár” tulajdonság mindkét tételben közös. Az üzlet tulajdonosa szeretné tárolni az ingatlanokat, majd hogyan fogja tárolni az iratokat.

Kezdetben úgy döntöttek, hogy az alábbi struktúrában tárolják a rekordokat:

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

A fenti struktúra tartalmazza az összes olyan elemet, amelyet az üzlet tulajdonosa tárolni szeretne. A fenti szerkezet teljesen használható, de az ár közös tulajdon a tételeknél, a többi darab egyedi. Az olyan tulajdonságok, mint az ár, a *cím, a *szerző és az oldalszámok a Könyvekhez, míg a szín, a méret, a *design a Shirthez tartoznak.

átlag vs átlag

Nézzük meg, hogyan érhetjük el a struktúra tagjait .

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

A fenti kódban létrehoztunk egy típusú változót bolt . Az értékeket hozzárendeltük a változókhoz, cím, szerző, oldalszám, ár, de a könyv változó nem rendelkezik olyan tulajdonságokkal, mint a méret, szín és design. Ezért ez memóriapazarlás. A fenti struktúra mérete 44 bájt lenne.

Rengeteg helyet takaríthatunk meg, ha szakszervezeteket használunk.

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

A fenti kódban létrehoztunk egy store típusú változót. Mivel a fenti kódban az uniókat használtuk, így a változó által elfoglalt legnagyobb memóriát vesszük figyelembe a memóriafoglalásnál. A fenti program kimenete 32 bájt. A struktúrák esetében 44 bájtot, míg az unióknál 44 bájtot kaptunk. Ezért a 44 bájt nagyobb, mint a 32 bájt, így rengeteg memóriaterületet takarít meg.