ב-C++, כאשר אנו מגדירים מחלקה, אנו מאתחלים כמה משתנים בתוך המחלקה הזו. משתנים אלו הם 'משתנה האיבר' של המחלקה. אנו יכולים לאתחל את 'משתנה האיבר' על ידי שימוש בשיטת הקונסטרוקטור בתכנות C++. משתנה המקושר לאובייקט מחלקה מסוים ונגיש לכל השיטות או הפונקציות שלו מכונה 'משתנה איבר' ב-C++. במאמר זה, נכריז על 'משתני חבר' אלה בקוד C++ ונסביר כאן בפירוט את 'משתני החברים'.
דוגמה 1:
בואו נתחיל כאן קצת קוד על ידי הכללת 'קובץ הכותרת' שאנו דורשים במהלך הקוד הזה. ה'iostream' הוא קובץ הכותרת שאנו מכניסים לקוד זה. קובץ כותרת זה כולל כמה שיותר פונקציות שאנו צריכים בקוד זה ומוצהרות בו. לאחר מכן, עלינו לכלול את מרחב השמות, שהוא ה-'std', אז נוסיף אותו כאן על ידי הצבת מילת המפתח 'שימוש' עם ה-'Namespace std'.
אנחנו לא צריכים להוסיף את ה-'std' הזה עם הפונקציות בנפרד. לאחר מכן, אנו מגדירים מחלקה בשם 'SampleClass' ומשתמשים בבנאי 'ציבורי'. בבנאי 'ציבורי' זה, אנו מצהירים על כמה משתני איברים שניגש אליהם בפונקציות החברים שלנו מאוחר יותר. משתני האיברים שאנו מצהירים כאן הם 'mVar1' ו-'mVar2' מסוג הנתונים 'int'.
לאחר מכן, אנו מכריזים על פונקציה מתחת לזה ששמה 'setValues()'. בפונקציה 'setValues()' זו, אנו מניחים את ה-'cout' כדי להדפיס את ההודעה המורה למשתמש להזין שני ערכים. שני הערכים שהמשתמש יזין נשמרים במשתנים 'mVar1' ו-'mVar2'. אנו מקבלים את הערכים הללו בעזרת שיטת 'צין'. לאחר קבלת שני הערכים ושמירתם ב-'mVar1' ו-'mVar2', אנו מגדירים פונקציה נוספת מתחת לזה. השם של הפונקציה הזו הוא 'getValues' שבו אנו משתמשים בהצהרות 'cout'.
כאן, אנו מניחים את ה-'mVar1' ו-'mVar2' שוב ב-'cout' כדי להציג את שני הערכים שקיבלנו מהמשתמש הקודם. מתחת לזה, אנו קוראים למתודה 'main()' שבה נוצר אובייקט המחלקה. השם של אובייקט המחלקה הוא 'sc1'. לאחר מכן, אנו קוראים לפונקציה הראשונה שהיא 'setValues' אותה אנו מגדירים כאן עם האובייקט 'sc1'.
לאחר מכן, נמקם שוב את שם האובייקט ונקרא לפונקציה השנייה שהיא 'getValues()' עם שם האובייקט 'sc1'. כעת, הוא מקבל תחילה את הערכים ולאחר מכן מציג אותם במסוף כאשר אנו קוראים לשתי המתודות עם אובייקט המחלקה שבו ניגש למשתנה האיבר בקוד זה.
קוד 1:
#includeשימוש במרחב שמות std;
class SampleClass {
פּוּמְבֵּי:
int mVar1, mVar2;
void setValues ( ) {
cout <> mVar1 >> mVar2;
}
void getValues ( ) {
cout << 'הערך של משתנה חבר ראשון = ' << mVar1 << endl ;
cout << 'הערך של משתנה חבר שני = ' << mVar2 << endl;
}
} ;
int main ( )
{
SampleClass sc1;
sc1.setValues ( ) ;
sc1.getValues ( ) ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
זה מדפיס את ההודעה תחילה. לאחר מכן, אנו מזינים '12' ו-'456' בתור ערכי הקלט המאוחסנים במשתני החבר שהצהרנו בקוד. לאחר מכן, הוא מציג את ערכי שני המשתנים כאשר אנו ניגשים אליהם באמצעות פונקציית חבר.
דוגמה 2:
כעת, אנו מגדירים מחלקה בשם 'ProductClass' לאחר הוספת קובץ הכותרת 'iostream' ומרחב השמות 'std'. ב-'ProductClass' זה, אנו משתמשים בבנאי 'ציבורי' בו אנו מצהירים על שני משתנים מסוג הנתונים 'int'. אלה הם 'ערך' ו'מכפיל' שהם משתני חבר.
לאחר מכן, אנו מגדירים כאן פונקציה עם השם, פונקציה 'calProductOfTwo()', כדי לגשת לשני המשתנים. זוהי פונקציית החבר כאן ואנחנו ניגשים למשתני החבר בפונקציה זו. אנו משתמשים במילת המפתח 'החזר' מתחת לזה וממקמים את 'מכפיל ערך*' שמחזיר את המכפלה של שני משתנים אלה.
לאחר מכן, אנו מפעילים את הפונקציה 'main()' בה אנו יוצרים את האובייקט של ה-'ProductClass' בשם 'p_obj' ולאחר מכן מקצים את הערכים למשתני האיברים שהכרזנו בעבר. אנו מאתחלים את המשתנים הללו בעזרת האובייקט 'מחלקה'. תחילה נמקם את שם האובייקט ולאחר מכן את שם המשתנה האיבר 'p_obj.value' ונקצה '33' למשתנה 'value'.
לאחר מכן, אנו מאתחלים את המשתנה 'מכפיל' ומקצים '98' למשתנה זה. כעת, אנו קוראים לפונקציה 'calProductOfTwo()' ב-'cout' עם האובייקט של המחלקה 'p_obj' המציגה את המכפלה של שני משתני האיברים.
קוד 2:
#includeשימוש במרחב שמות std;
Class ProductClass {
פּוּמְבֵּי:
ערך int;
מכפיל int;
int calProductOfTwo ( ) {
לַחֲזוֹר ערך * מַכפִּיל;
}
} ;
int main ( ) {
ProductClass p_obj;
p_obj.value = 33 ;
p_obj.multiplier = 98 ;
cout << 'המכפלה של שני ערכים = ' << p_obj.calProductOfTwo ( ) << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
מכפלת הערכים של משתני 'חבר' מוצג כאן. אנו יכולים לראות שאנו ניגשים למשתני 'חבר' בתוך הפונקציה 'חבר' ומאתחלים אותם לאחר יצירת האובייקט 'מחלקה' וקריאה לפונקציה 'חבר' בקוד שלנו. המכפלה של הערכים של שני משתני האיברים ניתן בסעיף הבא:
דוגמה 3:
ה'SumClass' מוגדר כאן בקוד זה. לאחר מכן, ב-'public', אנו מצהירים על שלושה משתני חברים עם השמות 's_val_1', 's_val_2' ו-'s_val_3' וסוג הנתונים של כל המשתנים הוא 'int'. לאחר מכן, אנו מגדירים פונקציה 'calSumOfTwo()' שהיא הפונקציה 'member' ואנחנו ניגשים למשתנים בפונקציה זו. ב-'calSumOfTwo()', אנו משתמשים במילת המפתח 'החזרה'. כאן אנו מניחים את 's_val_1 + s_val_2'.
כעת, הוא נותן את הסכום של שני המשתנים הללו. מתחת לזה, אנו מגדירים עוד פונקציה אחת שהיא 'calSumOfThree()'. בפונקציה זו, אנו ניגשים לכל שלושת המשתנים כדי למצוא את הסכום שלהם ולהחזיר את התוצאה שלהם כאן. לאחר מכן, אנו קוראים לשיטת 'main()'. האובייקט 'מחלקה' שנוצר כאן הוא 'sObj1'.
לאחר מכן, אנו מאתחלים כאן את כל שלושת משתני האיברים בעזרת האובייקט 'class' ומקצים '33', '98' ו-'195' ל-'s_val_1', 's_val_2' ו-'s_val_3', בהתאמה. לאחר מכן, אנו קוראים לשתי הפונקציות 'איבר' ב-'cout' שבה 'calSumOfTwo()' מציג את סכום שני המשתנים הראשונים וה-'calSumOfThree()' מציג את הסכום של כל שלושת משתני האיברים.
קוד 3:
#includeשימוש במרחב שמות std;
מחלקה SumClass {
פּוּמְבֵּי:
int s_val_1;
int s_val_2;
int s_val_3;
int calSumOfTwo ( ) {
לַחֲזוֹר s_val_1 + s_val_2;
}
int calSumOfThree ( ) {
לַחֲזוֹר s_val_1 + s_val_2 + s_val_3;
}
} ;
int main ( ) {
SumClass sObj1;
sObj1.s_val_1 = 33 ;
sObj1.s_val_2 = 98 ;
sObj1.s_val_3 = 195 ;
cout << 'הסכום של שני ערכים = ' << sObj1.calSumOfTwo ( ) << endl;
cout << 'הסכום של שלושה ערכים = ' << sObj1.calSumOfThree ( ) << endl;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הסכום של שני משתני האיבר הראשונים הוא '131' שאנו מקבלים כאן על ידי קריאה לפונקציית 'איבר' הראשונה. הסכום של כל שלושת משתני האיברים הוא '326' אותו אנו מקבלים על ידי קריאה לפונקציית 'חבר' השנייה בקוד שלנו.
סיכום
'משתני החברים' בתכנות C++ נחקרים לעומק במאמר זה. הסברנו ש'משתני האיבר' מוכרזים לאחר הגדרת המחלקה. משתנים אלו נגישים מכל מקום בקוד לאחר יצירת האובייקט 'מחלקה'. אנו יכולים לגשת למשתני איברים אלה גם בפונקציות 'חבר'. אתחול המשתנים הללו לאחר יצירת האובייקט 'מחלקה'. כאן, הכרזנו, אתחלנו וניגשנו ל'משתני חבר' בקוד C++ שלנו.