C ++ היא שפת תכנות גמישה למטרות כלליות. הוא נוצר במקור על ידי ביארנה סטרוסטרופ, מדען מחשבים דני, עוד בשנת 1985. C ++ תומך בשיטות מעבר של שלושה פרמטרים, קרי, שיחה לפי ערך, שיחה לפי כתובת והתקשרות לפי הפניה. במאמר זה, אנו הולכים לדון בנושא שיחה לפי כתובת ושיחה לפי מנגנון התייחסות.
מהי פונקציה?
לפני שנקפוץ לנושא האמיתי, עלינו להבין מה הפונקציה ב- C ++. ייתכן שרבים מכם כבר מכירים את הפונקציות.
פונקציה היא בעצם פיסת קוד שניתן להשתמש בה לביצוע משימה מסוימת. פונקציה משמשת בעיקר להפחתת הקוד החוזר בתוכנית C ++. הוא לוקח קלט כפרמטרים ומחזיר את הפלט כערך החזרה. אם נגדיר את הפונקציה פעם אחת, נוכל לקרוא/להשתמש בה מספר פעמים בחלק המאוחר יותר של התוכנית שלנו. כך, אנו חוסכים הרבה קוד חוזר בתוכנית.
לכל תוכנית C ++ תהיה הפונקציה הראשית (). הפונקציה הראשית () היא נקודת הכניסה לתוכנית C ++. מלבד הפונקציה הראשית (), המתכנת יכול להגדיר כמה פונקציות שהוא רוצה.
להלן התחביר של הגדרת פונקציה:
Return_type Function_Name(רשימת פרמטרי קלט)
פונקציה ב- C ++ יכולה לקבל 0 או יותר של פרמטרי קלט, ואילו היא יכולה להחזיר רק ערך החזרה אחד.
מהי כתובת?
ישנם שני סוגים של משתנים ב- C ++ (בדומה לשפת C) - משתנה נתונים ומשתנה כתובת. משתנה הכתובת משמש לאחסון הכתובת של משתנה נתונים אחר. לדוגמה, הבה נבחן את קטע הקוד הבא:
intאני= 100;
int *ptr= &אני;
כאן, המשפט הראשון אומר לנו שהמשתנה i הוא משתנה נתונים, והוא שומר את הערך 100. בהצהרה השנייה, אנו מכריזים על משתנה מצביע, כלומר ptr, ומתחילים אותו עם כתובת המשתנה i.
מה זה הפניה?
ההפניה היא תכונה עוצמתית נוספת של שפת C ++. הבה נבחן את קטע הקוד הבא:
intל= 200;int &r=ל;
בדוגמה זו, הכרזנו מספר שלם, כלומר a ולאחר מכן הכרזנו על משתנה התייחסות r, שמאתחל בערך של a. אם כן, משתנה ההתייחסות אינו אלא כינוי של משתנה אחר.
שיטות מעבר של פרמטרים:
ישנם שלושה סוגים של שיטות העברת פרמטרים בשפת C ++:
- התקשר לפי ערך / העבר לפי ערך
- התקשר לפי כתובת / העבר לפי כתובת
- התקשר בהפניה / העבר בהפניה
במאמר זה אנו דנים בנושא - שיחה לפי כתובת והתקשרות לפי התייחסות.
מהו שיחה לפי כתובת / העברת כתובת?
במקרה של שיטת Call by address / Pass by address, ארגומנטים של הפונקציה מועברים ככתובת. פונקציית המתקשר מעבירה את כתובת הפרמטרים. משתני מצביע משמשים בהגדרת הפונקציה. בעזרת שיטת Call by address, הפונקציה יכולה לגשת לפרמטרים בפועל ולשנות אותם. נראה דוגמה לשיטת השיחה לפי כתובת בהמשך החלק במאמר זה.
מהו Call by Reference / Pass by reference?
בשיטת Call by reference / Pass by reference, פרמטרי הפונקציה מועברים כהפניה. בתוך הגדרת הפונקציה, ניתן לגשת לפרמטרים בפועל באמצעות משתנה ההתייחסות.
דוגמאות:
כעת, מכיוון שאנו מבינים את הרעיון של שיטות העברת פרמטרים, נראה מספר תוכניות לדוגמא להבנת מנגנון העברת הפרמטרים ב- C ++:
- דוגמה 1-התקשרות לפי כתובת (1)
- דוגמה 2-התקשרות לפי כתובת (2)
- דוגמה 3-התקשר לפי הפניה (1)
- דוגמה 4-התקשר לפי הפניה (2)
שתי הדוגמאות הראשונות ניתנות כדי להסביר כיצד שיטת Call by address פועלת ב- C ++. שתי הדוגמאות האחרונות הן להסביר את המושג Call by reference.
דוגמה 1-התקשרות לפי כתובת (1)
בדוגמה זו, אנו הולכים להדגים את מנגנון השיחה לפי כתובת. מהפונקציה הראשית (), אנו קוראים לפונקציה הלו () ומעבירים את כתובת var. בהגדרת הפונקציה, אנו מקבלים את הכתובת של var במשתנה מצביע, כלומר עמ. בתוך הפונקציה שלום, הערך של var משתנה ל -200 בעזרת המצביע. לכן, הערך של var משתנה ל -200 בתוך הפונקציה הראשית () לאחר קריאת הפונקציה שלום ().
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
בָּטֵלשלום(int *עמ)
{
עֲלוּת <<endl<< הפונקציה 'בפנים הלו ():' <<endl;
עֲלוּת << 'ערך של *p =' << *עמ<<endl;
*עמ= 200;
עֲלוּת << 'ערך של *p =' << *עמ<<endl;
עֲלוּת << 'יציאה מ- Hello ().' <<endl;
}
intרָאשִׁי()
{
intאיפה= 100;
עֲלוּת << 'הערך של var בתוך main () function =' <<איפה<<endl;
שלום(&איפה);
עֲלוּת <<endl<< 'הערך של var בתוך main () function =' <<איפה<<endl;
לַחֲזוֹר 0;
}
דוגמה 2-התקשרות לפי כתובת (2)
זוהי דוגמה נוספת לשיטת השיחה לפי כתובת. בדוגמה זו, אנו הולכים להסביר כיצד ניתן להשתמש בשיטת השיחה לפי כתובת כדי לפתור בעיה אמיתית. לדוגמה, אנו רוצים לכתוב פונקציה להחלפת שני משתנים. אם אנו משתמשים במנגנון קריאה לפי ערך כדי להחליף שני משתנים, המשתנים בפועל אינם מתחלפים בפונקציית המתקשר. ניתן להשתמש בשיטת השיחה לפי כתובת בתרחיש כזה. בדוגמה זו, אנו מעבירים את הכתובת של var_1 (& var_1) ושל var_2 (& var_2) לפונקציה mySwap (). בתוך הפונקציה mySwap (), אנו מחליפים את הערכים של שני המשתנים הללו בעזרת הצבעים. כפי שאתה יכול לראות בפלט שלהלן, הערך האמיתי של משתנים אלה מתחלף בפונקציה הראשית () לאחר הפעלת הפונקציה mySwap ().
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
בָּטֵלmySwap(int *vptr_1,int *vptr_2)
{
inttemp_var;
temp_var= *vptr_1;
*vptr_1= *vptr_2;
*vptr_2=temp_var;
}
intרָאשִׁי()
{
intvar_1= 100;
intvar_2= 300;
עֲלוּת << 'לפני קריאת הפונקציה mySwap (), הערך של var_1:' <<var_1<<endl;
עֲלוּת << 'לפני קריאת הפונקציה mySwap (), הערך של var_2:' <<var_2<<endl<<endl;
עֲלוּת << 'התקשרות לפונקציית mySwap () - התקשר לפי כתובת.' <<endl<<endl;
mySwap(&var_1,&var_2);
עֲלוּת << 'לאחר קריאת הפונקציה mySwap (), הערך של var_1:' <<var_1<<endl;
עֲלוּת << 'לאחר קריאת הפונקציה mySwap (), הערך של var_2:' <<var_2<<endl;
לַחֲזוֹר 0;
}
דוגמה 3-התקשר לפי הפניה (1)
בדוגמה זו, אנו הולכים להדגים כיצד פועל שיחה באמצעות הפניה ב- C ++. בהגדרת הפונקציה hello (), הערך מתקבל כמשתנה התייחסות (& p). בעזרת משתנה ההתייחסות (כלומר, p), אנו מסוגלים לשנות את הערך של הפרמטר בפועל (var) בתוך הפונקציה הראשית ().
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
בָּטֵלשלום(int &עמ)
{
עֲלוּת <<endl<< הפונקציה 'בפנים הלו ():' <<endl;
עֲלוּת << 'ערך p =' <<עמ<<endl;
עמ= 200;
עֲלוּת << 'ערך p =' <<עמ<<endl;
עֲלוּת << 'יציאה מ- Hello ().' <<endl;
}
intרָאשִׁי()
{
intאיפה= 100;
עֲלוּת << 'הערך של var בתוך main () function =' <<איפה<<endl;
שלום(איפה);
עֲלוּת <<endl<< 'הערך של var בתוך main () function =' <<איפה<<endl;
לַחֲזוֹר 0;
}
דוגמה 4-התקשר לפי הפניה (2)
זוהי דוגמה נוספת לשיחה בהפניה. בדוגמה זו, אנו הולכים להדגים כיצד התקשרות באמצעות הפניה עובדות ב- C ++ בעזרת דוגמה בעולם האמיתי. הפונקציה mySwap () נקראת מהפונקציה הראשית () עם הפרמטרים הבאים - var_1 ו- var_2. בתוך הפונקציה mySwap (), אנו מקבלים את הפרמטרים כמשתני התייחסות.
#לִכלוֹלבאמצעות מרחב שמותשעה (ות;
בָּטֵלmySwap(int &vref_1,int &vref_2)
{
inttemp_var;
temp_var=vref_1;
vref_1=vref_2;
vref_2=temp_var;
}
intרָאשִׁי()
{
intvar_1= 100;
intvar_2= 300;
עֲלוּת << 'לפני קריאת הפונקציה mySwap (), הערך של var_1:' <<var_1<<endl;
עֲלוּת << 'לפני קריאת הפונקציה mySwap (), הערך של var_2:' <<var_2<<endl<<endl;
עֲלוּת << 'קורא לפונקציית mySwap () - התקשר בהתייחסות.' <<endl<<endl;
mySwap(var_1, var_2);
עֲלוּת << 'לאחר קריאת הפונקציה mySwap (), הערך של var_1:' <<var_1<<endl;
עֲלוּת << 'לאחר קריאת הפונקציה mySwap (), הערך של var_2:' <<var_2<<endl;
לַחֲזוֹר 0;
}
סיכום
הבנת שיטות העברת הפרמטרים פנימה C ++ הוא מכריע מאוד. שפת התכנות C תומכת בערך Call and Value by Address בלבד. אבל, C ++ תומך בשיחה בהתייחסות יחד עם שני המנגנונים הקודמים. במאמר זה, ראינו מספר דוגמאות עבודה להבנת המושג התקשרות לפי כתובת והתקשרות בהתייחסות. שיחה לפי כתובת היא שיטה עוצמתית ופופולרית ביותר ביישומי דומיין מוטבעים.