C++ מספק מתקן להחזרת ערך או כתובת לפי ההפניה שלו במקום מצביעים. שימוש בהפניות במקום מצביעים יכול להפוך תוכנית C++ לפשוטה יותר לקריאה ולניהול. ב-C++, הפניות ומצביעים קשורים זה לזה באופן הדוק. ההבחנה העיקרית היא שלמרות שהפניות הן רק שם חלופי, 'כינוי' למשתנה אחר, ניתן להשתמש במצביעים בפעולות כמו הוספת ערכים. הפניה היא שם חלופי או שכפול של הערך המקורי ומסומנת בסמל '&'.
דוגמה 1:
אנו מייבאים את קובץ הכותרת 'iostream' ולאחר מכן משתמשים במרחב השמות 'std'. קבצי הכותרות מיובאים בקודי C++ כפי שהוגדרו פונקציות רבות. לאחר מכן, אנו יוצרים פונקציית הפניה להחזרה על ידי הצבת הסמל '&' עם שם הפונקציה, 'returnTheValue'.
כאן, ההפניה 'ערך' מוכנסת כעת. מתחת לזה, אנו מדפיסים את הערך ואת הכתובת עם ההפניה '&value'. לאחר מכן, אנו מציבים את הפניה להחזר וממקמים את ה'ערך'. כעת, ה-'main()' מופעל כאן, ואנו מאתחלים את 'n1' עם הערך של '44'. מתחת לזה, 'int& n2' מאותחל עם ה-'returnTheValue(n1)'. כעת, אנו מדפיסים את הערך של 'n1' וכן את הכתובת שלו. לאחר מכן, אנו מדפיסים את הערך של 'n2' וכן את הכתובת של 'n2' על ידי שימוש ב-'cout'.
קוד 1:
#include
שימוש במרחב שמות std;
int & returnTheValue ( int & ערך )
{
cout << 'ערך = ' << ערך << endl
<< 'כתובת הערך היא'
<< & ערך << endl;
לַחֲזוֹר ערך;
}
int main ( )
{
אתה n1 = 44 ;
int & n2 = returnTheValue ( n1 ) ;
cout << 'n1 = ' << n1 << endl
<< 'הכתובת של n1 היא'
<< & n1 << endl;
cout << 'n2 = ' << n2 << endl
<< 'הכתובת של n2 היא'
<< & n2 << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, אנו יכולים לציין שהפניה היא רק שם חלופי של משתנה אחר, כפי שמוצג להלן. ככתובת הערך, 'n1' ו-'n2' לעולם לא משתנים.
דוגמה 2:
אנו משתמשים במרחב השמות 'std' לאחר ייבוא קובץ הכותרת 'iostream'. לאחר מכן, אנו משתמשים בשם הפונקציה 'MyReturnValueFunc' ובסמל '&' כדי לבנות פונקציית הפניה להחזרה. ההפניה למשתנה 'v1' ממוקמת כאן. אנו מדפיסים את הערך ואת הכתובת עם ההפניה '&v1' מתחת לזה. לאחר מכן, אנו מכניסים את 'הפניה להחזרה' על ידי שימוש ב'החזרה' ו-'v1' במיקום זה. כאן נקרא 'main()', ו-'num_1' מאותחל עם הערך של '19'. האתחול של 'int& num_2' נעשה באמצעות 'MyReturnValueFunc(num_1)'.
נכון לעכשיו, אנו מדפיסים את הערך והכתובת של 'num_1', ובאמצעות 'cout', אנו מדפיסים את הערך והכתובת של 'num_2'. כעת אנו משנים את הערך של 'num_1' על ידי שימוש בכתובת המוחזרת כאן על ידי 'MyReturnValueFunc'. פונקציה זו מחזירה את השם החלופי של 'v1' שהוא גם השם החלופי של 'num_1'. אז, אנו משנים את הערך שלו ומגדירים אותו ל-'91'. אנו מקצים '91' ל-'MyReturnValueFunc(num_1)' שמתפקד ככינוי כאן. לאחר מכן, נדפיס שוב את הערך ואת הכתובת של 'num_1'.
קוד 2:
#includeשימוש במרחב שמות std;
int & MyReturnValueFunc ( int & v1 )
{
cout << 'הערך של v1 = ' << v1 << endl
<< 'הכתובת של משתנה v1 היא'
<< & v1 << endl;
לַחֲזוֹר v1;
}
int main ( )
{
int num_1 = 19 ;
int & num_2 = MyReturnValueFunc ( מספר_1 ) ;
cout << 'הערך של num_1 = ' << מספר_1 << endl
<< ' הכתובת של num_1 היא '
<< & מספר_1 << endl;
cout << 'הערך של num_2 = ' << מספר_2 << endl
<< ' הכתובת של num_2 היא '
<< & מספר_2 << endl;
MyReturnValueFunc ( מספר_1 ) = 91 ;
cout << 'עכשיו, הערך של num_1 = ' << מספר_1 << endl
<< 'הכתובת של num_1 היא '
<< & מספר_1 << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כפי שהודגם בהמשך, אנו יכולים לראות שהפניה היא רק שם חלופי למשתנה אחר שכן הכתובת של הערכים 'v1', 'num_1' ו-'num_2' נשארה קבועה:
דוגמה 3:
קובץ הכותרת 'iostream' מיובא ונעשה שימוש במרחב השמות 'std'. מכיוון שמספר פונקציות מצוינות בקבצי הכותרות, אנו מייבאים אותן לקודי C++. כאן, אנו יוצרים פונקציה 'ReturnRefFun()' בה אנו מניחים את 'int& my_ref' שמחזירה את ההפניה. ה- 'int& ReturnRefFun' מוצהר כאן כפונקציית ההפניה. לאחר מכן, אנו מגדילים את הערך של המשתנה 'my_ref'. מתחת לזה, שמנו את 'החזרה' שמחזירה את ההפניה של 'שלי_ref'.
לאחר מכן, השיטה 'main()' מופעלת כאן. לאחר מכן, אנו מאתחלים את המשתנה 'first_value' עם '21'. מתחת לזה, אנו מחזירים את העותק של ההפניה על ידי הצבת 'first_value' בפונקציה 'ReturnRefFun' ונשמור אותו במשתנה 'copied_value'. לאחר מכן, אנו מדפיסים גם את ה-'first_value' וגם ה-'copyed_value' על ידי שימוש ב-'cout'. מתחת לזה, אנו מגדילים את המשתנה 'copied_value' על ידי הצבת ה-'copied_value++'. לאחר מכן, אנו מדפיסים את ה-'copyd_value' לאחר העלאתו ואת ה-'first_value' באמצעות 'cout'. לאחר מכן, נחזיר את ההפניה בעזרת אתחול המשתנה 'int& ref_value' עם 'ReturnRefFun(first_value)'.
לאחר מכן, אנו מדפיסים את הערך של המשתנה 'my_ref' שהעתקנו. לאחר מכן, אנו מדפיסים את הערך של המשתנה 'first_value'. מתחת לזה, אנו מגדילים את הערך של 'ref_value' על ידי הוספת 'ref_value++'. מתחת לזה, אנו מדפיסים את הערך המוגדל של 'ref_value' וגם את המשתנה 'first_value' בעזרת 'cout'. כאשר ה-'ref_value' משתנה, ה-'first_value' ישתנה גם הוא.
קוד 3:
#includeשימוש במרחב שמות std;
int & ReturnRefFun ( int & שלי_ref ) {
my_ref++;
לַחֲזוֹר שלי_ref;
}
int main ( ) {
int first_value = עשרים ואחת ;
int copied_value =ReturnRefFun ( first_value ) ;
cout << 'הערך הראשון הוא:' << first_value << endl;
cout << 'הערך שהועתק הוא: ' << copied_value << endl;
copied_value++;
cout << 'ה-copyd_value מוגדל: ' << copied_value << endl;
cout << 'הערך הראשון:' << first_value << endl;
int & ref_value =ReturnRefFun ( first_value ) ;
cout << 'ערך ההפניה שהועתק:' << ref_value << endl;
cout << 'הערך הראשון:' << first_value << endl;
ref_value++;
cout << 'ערך ההתייחסות מוגדל :' << ref_value << endl;
cout << 'הערך הראשון:' << first_value << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הנה התוצאה של הקוד הקודם שבו השתמשנו בטכניקת 'הפניה להחזרה'. הדוגמה מראה את ההבחנה בין החזרת כפיל של משתנה ההתייחסות לבין החזרת משתנה הייחוס עצמו.
דוגמה 4:
כאן, 'int&rByRef' מוכרז כפונקציית הפניה שמחזירה את משתנה ההפניה. אנו מעבירים את 'int& data' לפונקציית 'int& rByref()' הזו. כאן, אנו מדפיסים את הכתובת של המשתנה 'נתונים' ולאחר מכן משתמשים בהפניה להחזרה מתחת לזה. כעת, אנו מאתחלים את המשתנה 'x_var' לאחר הפעלת שיטת 'main()'. לאחר מכן, אנו מדפיסים את הכתובת של 'x_var' כאן על ידי הכנסת ה-'&x_var' ב-'cout'.
מתחת לזה, אנו משתמשים במשתנה ההתייחסות על ידי הקצאת 'rByref(x_var)' ל-'int&y_var'. לאחר מכן, אנו מדפיסים גם את הכתובת של אותו משתנה התייחסות '&y_var'. מתחת לזה, אנו מעתיקים את המשתנה 'x_var' למשתנה 'z_var' וגם מדפיסים את הכתובת של המשתנה המועתק הזה שהוא '&z_var'. לאחר מכן, אנו קוראים לפונקציה 'rByref()', מעבירים את המשתנה 'x_var' כפרמטר בתוכה, ומקצים '93' למשתנה זה. אנו גם מעבדים שוב את הכתובת של ה-'x_var' על ידי הכנסת ה-'&x_var' ב-'cout'.
קוד 4:
#includeשימוש במרחב שמות std;
int & rByref ( int & נתונים )
{
cout << 'כתובת הנתונים:' << & נתונים << endl;
לַחֲזוֹר נתונים;
}
int main ( )
{
int x_var = 42 ;
cout << 'כתובת של x_var: ' << & x_var << endl;
int & y_var = rByref ( x_var ) ;
cout << 'כתובת של y_var: ' << & y_var << endl;
int z_var = rByref ( x_var ) ;
cout << 'כתובת של z_var: ' << & z_var << endl;
rByref ( x_var ) = 93 ;
cout << 'כתובת של x_var: ' << & x_var << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
התוצאה מבהירה שהכתובת של המשתנה המשובט, 'z_var', שונה מכל המיקומים האחרים שהמשתנה המקורי, 'x_var', מפנה.
סיכום
המושג 'הפניה להחזרה' נחקר במדריך זה בפירוט. למדנו ש'הפניה להחזר' דומה ל'מצביעים' בתכנות C++. דנו שכדי לציין איזו פונקציה מחזירה הפניה, יש להשתמש בסמל '&' עם סוג ההחזרה של הפונקציה. הדגמנו כמה דוגמאות ואת התוצאות שלהן והבנו את המושג הזה במדריך זה.