съюз може да се дефинира като дефиниран от потребителя тип данни, който е колекция от различни променливи от различни типове данни в едно и също място в паметта. Обединението може също да бъде дефинирано като много членове, но само един член може да съдържа стойност в определен момент от време.
Union е дефиниран от потребителя тип данни, но за разлика от структурите, те споделят едно и също място в паметта.
Нека разберем това чрез пример.
struct abc { int a; char b; } Горният код е дефинирана от потребителя структура, която се състои от два члена, т.е. „a“ от тип вътр и 'b' от тип характер . Когато проверихме адресите на 'a' и 'b', установихме, че техните адреси са различни. Следователно заключаваме, че членовете в структурата не споделят едно и също място в паметта.
Когато дефинираме обединението, открихме, че обединението се дефинира по същия начин, както се дефинира структурата, но разликата е, че ключовата дума union се използва за дефиниране на типа данни на обединението, докато ключовата дума struct се използва за дефиниране на структурата. Обединението съдържа членовете на данните, т.е. „a“ и „b“, когато проверим адресите на двете променливи, открихме, че и двете имат едни и същи адреси. Това означава, че членовете на съюза споделят едно и също място в паметта.
Нека да разгледаме графичното представяне на разпределението на паметта.
Фигурата по-долу показва графично представяне на структурата. Структурата е двучленна; т.е. единият е от целочислен тип, а другият е от символен тип. Тъй като 1 блок е равен на 1 байт; следователно на променлива 'a' ще бъдат разпределени 4 блока памет, докато на променлива 'b' ще бъде разпределен 1 блок памет.
Фигурата по-долу показва графичното представяне на членовете на синдиката. И двете променливи споделят едно и също място в паметта и имат същия начален адрес.
В обединението членовете ще споделят местоположението на паметта. Ако се опитаме да направим промени в някой от членовете, това ще бъде отразено и на другия член. Нека разберем тази концепция чрез пример.
union abc { int a; char b; }var; int main() { var.a = 66; printf('
a = %d', var.a); printf('
b = %d', var.b); } В горния код обединението има два члена, т.е. „a“ и „b“. „var“ е променлива от тип union abc. В основен () метод, присвояваме 66 на променлива 'a', така че var.a ще отпечата 66 на екрана. Тъй като и 'a', и 'b' споделят местоположението на паметта, вар.б ще отпечата ' Б ' (ascii код от 66).
Определяне на размера на съюза
Размерът на съюза се основава на размера на най-големия член на съюза.
Нека разберем чрез пример.
union abc{ int a; char b; float c; double d; }; int main() { printf('Size of union abc is %d', sizeof(union abc)); return 0; } Както знаем, размерът на int е 4 байта, размерът на char е 1 байт, размерът на float е 4 байта, а размерът на double е 8 байта. Тъй като двойната променлива заема най-голямата памет сред всичките четири променливи, така че общо 8 байта ще бъдат разпределени в паметта. Следователно изходът от горната програма ще бъде 8 байта.
Достъп до членовете на съюза чрез указатели
Можем да имаме достъп до членовете на съюза чрез указатели, като използваме оператора със стрелка (->).
Нека разберем чрез пример.
#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; } В горния код създадохме променлива указател, т.е. *ptr, която съхранява адреса на променливата var. Сега ptr има достъп до променливата 'a' с помощта на оператора (->). Следователно резултатът от горния код ще бъде 90.
Защо имаме нужда от C съюзи?
Помислете за един пример, за да разберете необходимостта от C съюзи. Нека разгледаме магазин, който има два артикула:
- Книги
- Ризи
Собствениците на магазини искат да съхраняват записите на гореспоменатите два елемента заедно със съответната информация. Например книгите включват заглавие, автор, брой страници, цена, а ризите включват цвят, дизайн, размер и цена. Свойството „цена“ е често срещано и в двата елемента. Собственикът на магазина иска да съхранява свойствата, след това как той/тя ще съхранява записите.
Първоначално те решават да съхраняват записите в структура, както е показано по-долу:
struct store { double price; char *title; char *author; int number_pages; int color; int size; char *design; }; Горната структура се състои от всички елементи, които собственикът на магазина иска да съхранява. Горната структура е напълно използваема, но цената е обща собственост и на двата артикула, а останалите артикули са индивидуални. Свойства като цена, *заглавие, *автор и брой_страници принадлежат на Книги, докато цвят, размер, *дизайн принадлежат на Риза.
колко голям е екрана на компютъра ми
Нека видим как можем да получим достъп до членовете на структурата .
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; } В горния код създадохме променлива от тип магазин . Присвоихме стойностите на променливите, заглавие, автор, брой_страници, цена, но променливата книга не притежава свойства като размер, цвят и дизайн. Следователно това е загуба на памет. Размерът на горната структура ще бъде 44 байта.
Можем да спестим много място, ако използваме съюзи.
#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; } В горния код създадохме променлива от тип store. Тъй като използвахме обединенията в горния код, най-голямата памет, заета от променливата, ще бъде взета предвид за разпределението на паметта. Резултатът от горната програма е 32 байта. В случай на структури получихме 44 байта, докато в случай на обединения, полученият размер е 44 байта. Следователно 44 байта са повече от 32 байта, спестявайки много място в паметта.