דוגמה 1:
אנו כוללים את קובץ הכותרת 'iostream' כדי להקל על השימוש בפונקציות המוגדרות. לאחר מכן, יש לנו את 'מרחב השמות std'. מתחת לזה, אנו יוצרים את המחלקה בשם 'MyNewClass' ומשתמשים בבנאי 'ציבורי'.
ב-'public', אנו יוצרים את פונקציית החבר בשם 'myFunc' ומצהירים על 'int num' כפרמטר של 'myFunc()'. מתחת לזה, אנו משתמשים ב-'cout' ומפעילים את השיטה main() שמתחת זו, בה אנו יוצרים את מצביע הפונקציה איבר. אנו מכריזים על המצביע 'MyFuncPtr' לסוג הפונקציה חבר, תוך ציון המחלקה 'MyNewClass' וסוג הפרמטר (int).
לאחר מכן, אנו יוצרים את אובייקט המחלקה בשם 'Class_obj' ואז קוראים לפונקציית החברים בעזרת מצביע '*MyFuncPtr' על ידי הצבת אובייקט המחלקה עם זה. אנו מקצים '10' כפרמטר לעיבוד זה כאשר אנו קוראים למצביע הפונקציה האיבר.
קוד 1:
#includeבאמצעות מרחב שמות std ;
class MyNewClass {
פּוּמְבֵּי :
בָּטֵל myFunc ( int על אחד ) {
cout << 'הערך הוא' << על אחד << endl ;
}
} ;
int רָאשִׁי ( ) {
בָּטֵל ( MyNewClass ::* MyFuncPtr ) ( int ) = & MyNewClass :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
זה ממחיש את פעולתם של מצביעי פונקציות חבר. ניתן להשתמש במצביע הפונקציה חבר כדי להפעיל את פונקציות החבר באופן דינמי בהתאם לתנאים הנוכחיים.
דוגמה 2:
כדי להשתמש בפונקציות המוגדרות בקובץ הכותרת 'iostream' פשוט, אנו כוללים את 'iostream' כאן. ה-'Namespace std' מונח לאחר מכן. מתחתיו, אנו יוצרים את המחלקה 'Test' ולאחר מכן משתמשים בבנאי 'ציבורי'. אנו מגדירים את פונקציית החברים ' myTestingFunc ' ב- 'public' ומגדירים את 'int t_value' כפרמטר עבור ' myTestingFunc()' במקרה זה. הפונקציה 'cout' משמשת למטה ונקראת השיטה main(). לאחר מכן, אנו יוצרים את מצביע הפונקציה איבר.
אנו מציינים את המחלקה 'Test' ואת מצביע הפונקציה '*MyTestFuncPtr' של חבר כאן. אנו מקצים את '&Test::myTestingFunc' למצביע הפונקציה האיבר המוכרז כ-'void (Test::*MyTestFuncPtr)(int)'.
לאחר מכן, אנו יוצרים את אובייקט המחלקה 't_obj' ומשתמשים בו כדי לקרוא לפונקציה איבר על ידי הצבת אובייקט המחלקה ושימוש במצביע '*MyTestFuncPtr'. כדי שזה יוצג כאשר אנו קוראים למצביע הפונקציה האיבר, אנו מקצים '932' כפרמטר.
קוד 2:
#includeבאמצעות מרחב שמות std ;
מבחן כיתתי {
פּוּמְבֵּי :
בָּטֵל myTestingFunc ( int t_value ) {
cout << 'ערך הבדיקה הוא' << t_value << endl ;
}
} ;
int רָאשִׁי ( ) {
בָּטֵל ( מִבְחָן ::* MyTestFuncPtr ) ( int ) = & מִבְחָן :: myTestingFunc ;
מבחן t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
התוצאה של הקוד הנתון מוצגת. אנו יכולים לראות שקראנו ל'מצביע פונקציית חבר' עם אובייקט המחלקה כפי שמוצג כאן.
דוגמה 3:
המחלקה שאנו יוצרים בקוד זה היא 'MyNewCar' שבה אנו משתמשים בבנאי ה'ציבורי' ויוצרים בו את פונקציית החברים שהיא 'startCarEngine()'. בפונקציה זו, אנו מוסיפים 'cout' אשר הופך כאשר אנו קוראים לפונקציה זו בקוד שלנו. לאחר מכן, אנו יוצרים פונקציית חבר נוספת שהיא 'stopCarEngine()' ונשתמש ב-'cout' שוב בפונקציית חבר זו.
לאחר מכן, אנו מפעילים את הפונקציה main() ואז מכריזים על מצביע הפונקציה חבר שהוא 'MyNewCar::*carEngineFunc()'. מתחת לזה, אנו יוצרים את אובייקט המחלקה 'MyNewCar' עם השם, 'myCar_obj'. לאחר מכן, אנו מקצים את הפונקציה 'startCarEngine' למצביע 'carEngineFunc'. מתחת לזה, אנו קוראים לפונקציה הזו בעזרת מצביע 'carEngineFunc' על ידי הצבת שם האובייקט איתה.
לאחר מכן, אנו מקצים מחדש את הפונקציה 'stopCarEngine' למצביע 'carEngineFunc'. מתחת לזה, אנו קוראים לפונקציה זו על ידי העברת שם האובייקט יחד עם ההפניה 'carEngineFunc'.
קוד 3:
#includeבאמצעות מרחב שמות std ;
מחלקה MyNewCar {
פּוּמְבֵּי :
בָּטֵל startCarEngine ( ) {
cout << 'המנוע של המכונית מתניע' << endl ;
}
בָּטֵל stopCarEngine ( ) {
cout << 'המנוע של המכונית עוצר' << endl ;
}
} ;
int רָאשִׁי ( ) {
בָּטֵל ( המכונית החדשה שלי ::* carEngineFunc ) ( ) ;
MyNewCar myCar_obj ;
carEngineFunc = & המכונית החדשה שלי :: startCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
carEngineFunc = & המכונית החדשה שלי :: stopCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן מוצגת פעולת 'מצביע פונקציית חבר'. אנו יכולים לראות שיצרנו את מצביע הפונקציה איבר והצגנו את התוצאה כאן.
דוגמה 4:
לאחר הכללת קובץ ה-header ו-'std namespace', אנו מכריזים כאן על המחלקה 'MyNewStudent'. פונקציית החבר ' studentPass()' היא אחת מפונקציות החבר שאנו בונים עבור המחלקה 'MyStudentClass' שאנו יוצרים כאן. אנו גם מוסיפים 'cout' לפונקציה הזו אשר תעבד כשנקרא לה בקוד שלנו.
לאחר מכן, אנו כותבים את פונקציית החבר 'studentFail()' שבה אנו משתמשים ב-'cout' פעם נוספת. לאחר מכן נקראת הפונקציה main() ומוכרז מצביע הפונקציה '(MyNewStudent::*studentResultFunc)()'. מתחת לזה, אנו יוצרים את האובייקט ' myStd_obj ' השייך למחלקה 'MyNewStudent'.
לאחר מכן, אנו מקצים את הפונקציה 'studentPass' למצביע 'studentResultFunc'. מתחת לזה, אנו קוראים לפונקציה הזו על ידי העברת שם האובייקט יחד עם ההפניה 'studentResultFunc'. הפונקציה 'studentFail' מוקצית מחדש למצביע 'studentResultFunc'. מתחת לזה, אנו מפעילים שיטה זו על ידי מתן ההפניה 'carEngineFunc' ושם האובייקט.
כעת, שתי הפונקציות נקראות כאן וההצהרות שכללנו בפונקציות הללו מוצגות.
קוד 4:
#includeבאמצעות מרחב שמות std ;
כיתה MyNewStudent {
פּוּמְבֵּי :
בָּטֵל studentPass ( ) {
cout << 'התלמיד עובר' << endl ;
}
בָּטֵל student נכשל ( ) {
cout << 'התלמיד נכשל' << endl ;
}
} ;
int רָאשִׁי ( ) {
בָּטֵל ( MyNewStudent ::* studentResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
studentResultFunc = & MyNewStudent :: studentPass ;
( myStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = & MyNewStudent :: student נכשל ;
( myStd_obj. * studentResultFunc ) ( ) ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
יצרנו את פונקציות האיבר בקוד שלנו ולאחר מכן את מצביע הפונקציה האיבר. לאחר מכן, קראנו לפונקציית חבר והצגנו כאן את התוצאה.
דוגמה 5:
ה-'SampleClass' נוצר במקרה זה. לאחר מכן, מצביע הפונקציה חבר ממוקם כאן שהוא '(SampleClass::*MyFunc)()'. מתחת לזה, אנו יוצרים את מצביע הפונקציה שהוא '(*MyFuncPtr)()'. מתחתיו, אנו מכריזים על ה'שם' של המשתנה 'מחרוזת' כמו גם על מצביע הפונקציה 'MyFunc f' של חבר.
לאחר מכן, יש לנו את הבנאי 'ציבורי' שבו אנו מגדירים את משתנה הפונקציה האיבר הזה. מתחת לזה, אנו יוצרים את פונקציות החבר בשם 'myFunc_1()' ו-'myFunc_1()' וגם מוסיפים 'cout' בכל פונקציית חבר אשר תוצג כאשר אנו קוראים לפונקציית חבר זו.
לאחר מכן, אנו קוראים למצביע הפונקציה האיבר הזה בעזרת '(this->*f)()'. לאחר מכן, נמקם את הפונקציות שוב. כאן, אנו משנים את הצהרות 'cout' שהוספנו בעבר. לאחר מכן, 'main()' מופעל כעת ומצביע הפונקציה האיבר מוגדר כ-'MyFunc f = &SampleClass::myFunc_2'.
לאחר מכן, מצביע הפונקציה מוגדר גם כ-'MyFuncPtr fp = myFunc_1'. לאחר מכן, נקליד '(a.*f)()' כדי להשתמש במצביע הפונקציה איבר. ה-'b.func' ממוקם כדי להשתמש בפונקציית חבר. לאחר מכן, אנו מניחים את 'fp()' כדי לקרוא למצביע הפונקציה.
קוד 5:
#includeבאמצעות מרחב שמות std ;
class SampleClass ;
typedef בָּטֵל ( SampleClass ::* MyFunc ) ( ) ;
typedef בָּטֵל ( * MyFuncPtr ) ( ) ;
class SampleClass {
שם מחרוזת ;
MyFunc f ;
פּוּמְבֵּי :
SampleClass ( const לְהַשְׁחִיר * שֵׁם )
: שֵׁם ( שֵׁם ) ,
ו ( & SampleClass :: myFunc_1 )
{ }
בָּטֵל myFunc_1 ( ) { cout << שֵׁם << 'קראנו לפונקציה 1 כאן' << endl ; }
בָּטֵל myFunc_2 ( ) { cout << שֵׁם << 'קראנו לפונקציה 2 כאן' << endl ; }
בָּטֵל func ( ) {
( זֶה ->* ו ) ( ) ;
}
} ;
בָּטֵל myFunc_1 ( ) { cout << 'הפונקציה הראשונה' << endl ; }
בָּטֵל myFunc_2 ( ) { cout << 'הפונקציה השנייה' << endl ; }
int רָאשִׁי ( )
{
MyFunc f = & SampleClass :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
SampleClass א ( 'ראשון - ' ) , ב ( 'שני -' ) ;
( א. * ו ) ( ) ;
ב. func ( ) ;
fp ( ) ;
}
תְפוּקָה:
התוצאה של הקוד מוצגת כאן כעת מה שמציג את התוצאה בהתאם כפי שקראנו לפונקציות בקוד שלנו.
סיכום
בדקנו ש'מצביעי פונקציות איברים' ב-C++ מקלים על הקישור הדינמי, עטיפה של התנהגות וטיפול גמיש בהפעלת פונקציה בהקשר של OOP. למדנו שהשימוש ב'מצביעי פונקציות חבר' יכול לשפר משמעותית את המודולריות והגמישות של בסיסי קוד C++, מה שמספק כלי רב עוצמה להתמודדות עם אתגרי עיצוב וזמן ריצה רבים.