הִתאַחֲדוּת ניתן להגדיר כסוג נתונים המוגדר על ידי המשתמש שהוא אוסף של משתנים שונים של סוגי נתונים שונים באותו מיקום זיכרון. ניתן להגדיר את האיגוד כחברים רבים, אך רק חבר אחד יכול להכיל ערך בנקודת זמן מסוימת.

Union הוא סוג נתונים המוגדר על ידי המשתמש, אך בניגוד למבנים, הם חולקים את אותו מיקום זיכרון.

מה זה אובונטו חיוני לבנייה

בואו נבין זאת באמצעות דוגמה.

 struct abc { int a; char b; } 

הקוד שלמעלה הוא המבנה המוגדר על ידי המשתמש המורכב משני איברים, כלומר 'a' מסוג int ו-'b' מסוג אופי . כשאנחנו בודקים את הכתובות של 'a' ו-'b', גילינו שהכתובות שלהם שונות. לכן, אנו מסיקים שהאיברים במבנה אינם חולקים את אותו מיקום זיכרון.

כאשר אנו מגדירים את האיחוד, אז מצאנו שאיחוד מוגדר באותו אופן שבו מוגדר המבנה, אבל ההבדל הוא שמילת מפתח איחוד משמשת להגדרת סוג הנתונים של האיחוד, בעוד שמילת המפתח struct משמשת להגדרת המבנה. האיחוד מכיל את חברי הנתונים, כלומר, 'a' ו-'b', כאשר אנו בודקים את הכתובות של שני המשתנים אז גילינו שלשניהם יש אותן כתובות. זה אומר שחברי האיגוד חולקים את אותו מיקום זיכרון.

בואו נסתכל על הייצוג הציורי של הקצאת הזיכרון.

האיור שלהלן מציג את הייצוג הציורי של המבנה. למבנה שני איברים; כלומר, אחד הוא מסוג מספר שלם, והשני הוא מסוג תו. מכיוון שבלוק 1 שווה ל-1 בייט; לכן, למשתנה 'a' יוקצה 4 בלוקים של זיכרון ואילו למשתנה 'b' יוקצה בלוק זיכרון אחד.

האיור שלהלן מציג את הייצוג הציורי של חברי האיגוד. שני המשתנים חולקים את אותו מיקום זיכרון ובעלי אותה כתובת ראשונית.

באיחוד, החברים ישתפו את מיקום הזיכרון. אם ננסה לבצע שינויים באחד מהחברים אז זה ישתקף גם לחבר השני. בואו נבין את המושג הזה באמצעות דוגמה.

 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' חולקים את מיקום הזיכרון, var.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 בתים, וגודל הכפול הוא 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.

טקסט גלישת css

למה אנחנו צריכים איגודי C?

שקול דוגמה אחת כדי להבין את הצורך באיגודי C. בואו ניקח בחשבון חנות שיש בה שני פריטים:

• ספרים
• חולצות

בעלי חנויות רוצים לאחסן את הרישומים של שני הפריטים הנ'ל יחד עם המידע הרלוונטי. לדוגמה, ספרים כוללים כותרת, מחבר, מספר עמודים, מחיר וחולצות כוללות צבע, עיצוב, גודל ומחיר. המאפיין 'מחיר' נפוץ בשני הפריטים. בעל החנות רוצה לאחסן את הנכסים, ואז איך הוא/היא יאחסן את הרשומות.

בתחילה, הם החליטו לאחסן את הרשומות במבנה כפי שמוצג להלן:

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

המבנה הנ'ל מורכב מכל הפריטים שבעל החנות רוצה לאחסן. המבנה הנ'ל הוא שמיש לחלוטין אך המחיר הוא רכוש משותף גם בפריטים וגם בשאר הפריטים הם בודדים. המאפיינים כמו price, *title, *author ו-number_pages שייכים ל-Books בעוד שצבע, מידה, *עיצוב שייכים ל-Shirt.

בואו נראה כיצד נוכל לגשת לחברי המבנה .

מערך java לרשימה

 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 בתים וחוסך הרבה שטח זיכרון.