מהי כריכה מובנית ב-C++?
קשירת מבנה היא תכונה C++ שנוספה ב-C++17 המאפשרת גם פירוק של מבנה או tuple למשתנים בודדים, מה שמשפר את תמציתי הקוד. ניתן להשתמש בו כדי להפוך את תחביר הגישה לחברי struct לפשוט יותר ולהפחית את האפשרות לשגיאות שנגרמו כתוצאה משגיאות הקלדה או אינדקס שגוי.
תחביר
התחביר של קשירת מבנה ב-C++ הוא כדלקמן:
אוטומטי [ var1 , גרסה 2 , ... ] = ביטוי ;
בתחביר לקשירת מבנה ב-C++, כאשר 'var1', ו-'var2' הם שמות משתנים, ו'ביטוי' הוא ביטוי שמניב מבנה או מחלקה. אנו משתמשים במילות מפתח אוטומטיות כדי להצהיר על משתנים שנוצרים אוטומטית.
משנה
ניתן להשתמש בשינויים בשילוב עם כריכות מובנות. התחביר שלהם מוזכר להלן:
אוטומטי & [ א , ב , ג , ... ] = ביטוי ;
אוטומטי && [ א , ב , ג , ... ] = ביטוי ;
האופרטור '&' או '&&' המשמש בהצהרה מגדיר אם הקישור הוא הפניה lvalue או rvalue. הפניה lvalue המיוצגת על ידי '&' קובעת הפניה שניתן להשתמש בה כדי לשנות את הערכים של המשתנים המחייבים. שינויים בערכים שנעשו באמצעות הפניה ייראו במבנה המקורי או בטופלה.
הפניה ל-rvalue המיוצגת על ידי '&&', מנגד, מספקת התייחסות המוגבלת לשימוש לקריאת הערך של המשתנים הכלולים בקישור. זה שימושי לקשירה לאובייקטים חולפים או לערכים rvalues שיש להשמיד מכיוון שהוא נמנע מיצירת העתק של האובייקט, זה יכול להיות זיכרון וזמן רב.
דוגמה 1: מחייב מבנה ב-C++
להלן דוגמה לקשירת מבנה C++:
#includeבאמצעות מרחב שמות std ;
מבנה קוּבִּיָה
{
int איקס ;
int ו ;
int עם ;
} ;
int רָאשִׁי ( )
{
c-cube = { 10 , עשרים , 30 } ;
אוטומטי [ x_coordinate , y_coordinate , z_coordinate ] = ג ;
cout << 'ציר X:' << x_coordinate << endl ;
cout << 'ציר Y:' << y_coordinate << endl ;
cout << 'ציר Z:' << z_coordinate << endl ;
לַחֲזוֹר 0 ;
}
בדוגמה לעיל, אנו מכריזים על קוביית struct עם שלושה מספרים שלמים x, y ו-z. המבנה מציג קובייה בחלל. נוצר משתנה c מסוג קובייה ומאותחל עם ערכים (10,20,30). במבנה קוד זה מקצה הקישור ערכים של איברים x, y ו-z של struct למשתנים הבודדים x_coordinate, y_coordinate, z_coordinate בהתאמה באמצעות תחביר auto[ x_coordinate, y_coordinate, z_coordinate ] = c. הפלט של האמור לעיל מוצג להלן:
דוגמה 2: כריכת מבנה ב-C++ לפריקת מבנה
להלן דוגמה לקשירת מבנה של פירוק מבנה:
#include#include
באמצעות מרחב שמות std ;
מבנה סטוּדֶנט {
שם מחרוזת ;
int גיל ;
} ;
int רָאשִׁי ( ) {
תלמיד s { 'חמזה' , 32 } ;
אוטומטי [ שֵׁם , גיל ] = ס ;
cout << שֵׁם << 'הוא' << גיל << ' שנים.' << endl ;
לַחֲזוֹר 0 ;
}
בקוד שלמעלה, מבנה Student כולל שני איברים: א שֵׁם זה מחרוזת וא גיל זה מספר שלם. לאחר מכן, אנו יוצרים את האובייקט Student ומקצים ערכים ראשוניים לכל אחד מחבריו. האיברים של s מופרדים לאחר מכן לשם וגילו של המשתנה באמצעות כריכה מבנית, וערכים אלה מודפסים לאחר מכן כמו בצילום המסך שלהלן:
דוגמה 3: מחייב מבנה ב-C++ עם משתנים
להלן דוגמה לקשירת מבנה שעושה שימוש במשנה כדי לעדכן את הערך של משתנה כ-num1 ו-num2:
#include#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
tuple < int , int > ט { 25 , עשרים } ;
אוטומטי & [ מספר 1 , מספר 2 ] = ט ;
cout << 'הערך של num1 = ' << מספר 1 << ', num2 = ' << מספר 2 << ' \n ' ;
מספר 1 = 30 ;
cout << 'הערך שהשתנה של num1 = ' << מספר 1 << ', num2 = ' << מספר 2 <<
' \n ' ;
אוטומטי && [ מספר 3 , מספר 4 ] = make_tuple ( 100 , 250 ) ;
cout << 'עכשיו הערך של num3 = ' << מספר 3 << ', num4 = ' << מספר 4 << ' \n ' ;
לַחֲזוֹר 0 ;
}
בקוד הקודם, אנו בונים tuple t ומשתמשים בהפניה lvalue כדי לקשר את הרכיבים שלו ל- num1 ו- num2. לאחר מכן נשנה את הערך של num1 ל-30 ונוציא את ערכי num1 ו- num2. בנה גם tuple זמני באמצעות make_tuple(100, 250) והשתמש בהפניה של rvalue כדי לקשור את האלמנטים שלו ל-num3 ו-num4. הערכים של num3 ו- num4 מודפסים לאחר מכן מכיוון ש- num3 ו- num4 משולבים עם הפניה ל-rvalue, לא ניתן להשתמש בהם כדי לשנות את ה-tuple הזמני שנוצר על-ידי make_tuple(100, 250). הם מסוגלים רק לקרוא ממנו. כאשר אתה מפעיל את התוכנית, התוצאה הבאה תוצג על המסך:
סיכום
קשירת מבנה היא תכונה ב-C++ המפרקת ערכים מרובים של מבנה או מחלקה למשתנים בודדים בביטוי יחיד, וכתוצאה מכך קוד תמציתי, קריא ובטוח יותר. קשירת מבנה באמצעות משנה מייעלת את תהליך שינוי הערכים בתוך אובייקטים מובנים.