Contoh 1:
Kami menyertakan fail pengepala 'iostream' untuk memudahkan penggunaan fungsi yang ditentukan. Kemudian, kami mempunyai 'ruang nama std'. Di bawah ini, kami menjana kelas bernama 'MyNewClass' dan menggunakan pembina 'awam'.
Dalam 'awam', kami mencipta fungsi ahli bernama 'myFunc' dan mengisytiharkan 'int num' sebagai parameter 'myFunc()'. Di bawah ini, kami menggunakan 'cout' dan menggunakan kaedah main() di bawah ini di mana kami mencipta penunjuk fungsi ahli. Kami mengisytiharkan penunjuk 'MyFuncPtr' kepada jenis fungsi ahli, menyatakan kelas 'MyNewClass' dan jenis parameter (int).
Selepas ini, kami mencipta objek kelas bernama 'Class_obj' dan kemudian memanggil fungsi ahli dengan bantuan penunjuk '*MyFuncPtr' dengan meletakkan objek kelas dengan ini. Kami menetapkan '10' sebagai parameter untuk menjadikannya apabila kami memanggil penunjuk fungsi ahli.
Kod 1:
#includemenggunakan ruang nama std ;
kelas MyNewClass {
awam :
batal myFunc ( int pada satu ) {
cout << 'Nilainya ialah' << pada satu << endl ;
}
} ;
int utama ( ) {
batal ( MyNewClass ::* MyFuncPtr ) ( int ) = & MyNewClass :: myFunc ;
MyNewClass Class_obj ;
( Kelas_obj. * MyFuncPtr ) ( 10 ) ;
kembali 0 ;
}
Pengeluaran:
Ini menggambarkan kerja penuding fungsi ahli. Penunjuk fungsi ahli boleh digunakan untuk melancarkan fungsi ahli secara dinamik mengikut keadaan semasa.
Contoh 2:
Untuk menggunakan fungsi yang ditakrifkan dalam fail pengepala 'iostream' mudah, kami menyertakan 'iostream' di sini. 'ruang nama std' diletakkan di sebelah. Di bawahnya, kami mencipta kelas 'Ujian' dan kemudian menggunakan pembina 'awam'. Kami mentakrifkan fungsi ahli ' myTestingFunc ' dalam 'awam' dan menetapkan 'int t_value' sebagai parameter untuk ' myTestingFunc()' dalam keadaan ini. Fungsi 'cout' digunakan di bawah dan kaedah main() dipanggil. Kemudian, kami mencipta penunjuk fungsi ahli.
Kami menentukan kelas 'Ujian' dan penunjuk fungsi ahli '*MyTestFuncPtr' di sini. Kami menetapkan '&Test::myTestingFunc' kepada penunjuk fungsi ahli yang diisytiharkan sebagai 'kosong (Ujian::*MyTestFuncPtr)(int)'.
Seterusnya, kami menjana objek kelas 't_obj' dan menggunakannya untuk memanggil fungsi ahli dengan meletakkan objek kelas dan menggunakan penunjuk '*MyTestFuncPtr'. Untuk ini dipersembahkan apabila kami memanggil penuding fungsi ahli, kami menetapkan '932' sebagai parameter.
Kod 2:
#includemenggunakan ruang nama std ;
Ujian kelas {
awam :
batal myTestingFunc ( int t_value ) {
cout << 'Nilai ujian ialah' << t_value << endl ;
}
} ;
int utama ( ) {
batal ( Ujian ::* MyTestFuncPtr ) ( int ) = & Ujian :: myTestingFunc ;
Uji t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
kembali 0 ;
}
Pengeluaran:
Hasil kod yang diberikan diberikan. Kita dapat melihat bahawa kita memanggil 'penunjuk fungsi ahli' dengan objek kelas seperti yang ditunjukkan di sini.
Contoh 3:
Kelas yang kami hasilkan dalam kod ini ialah 'MyNewCar' di mana kami menggunakan pembina 'awam' dan mencipta fungsi ahli di dalamnya iaitu 'startCarEngine()'. Dalam fungsi ini, kami menambah 'cout' yang menyebabkan apabila kami memanggil fungsi ini dalam kod kami. Kemudian, kami mencipta satu lagi fungsi ahli iaitu 'stopCarEngine()' dan menggunakan 'cout' sekali lagi dalam fungsi ahli ini.
Selepas ini, kami menggunakan fungsi main() dan kemudian mengisytiharkan penunjuk fungsi ahli iaitu 'MyNewCar::*carEngineFunc()'. Di bawah ini, kami mencipta objek kelas 'MyNewCar' dengan nama, 'myCar_obj'. Kemudian, kami menetapkan fungsi 'startCarEngine' kepada penunjuk 'carEngineFunc'. Di bawah ini, kami memanggil fungsi ini dengan bantuan penunjuk 'carEngineFunc' dengan meletakkan nama objek dengannya.
Seterusnya, kami menetapkan semula fungsi 'stopCarEngine' kepada penunjuk 'carEngineFunc'. Di bawah itu, kami memanggil fungsi ini dengan menghantar nama objek bersama-sama dengan rujukan 'carEngineFunc'.
Kod 3:
#includemenggunakan ruang nama std ;
kelas MyNewCar {
awam :
batal mulakanCarEngine ( ) {
cout << 'Enjin kereta dihidupkan' << endl ;
}
batal berhentiCarEnjin ( ) {
cout << 'Enjin kereta berhenti' << endl ;
}
} ;
int utama ( ) {
batal ( MyNewCar ::* carEnjinFunc ) ( ) ;
MyNewCar myCar_obj ;
carEnjinFunc = & MyNewCar :: mulakanCarEngine ;
( myCar_obj. * carEnjinFunc ) ( ) ;
carEnjinFunc = & MyNewCar :: berhentiCarEnjin ;
( myCar_obj. * carEnjinFunc ) ( ) ;
kembali 0 ;
}
Pengeluaran:
Di sini, kerja 'penunjuk fungsi ahli' dipaparkan. Kita dapat melihat bahawa kita mencipta penunjuk fungsi ahli dan memaparkan hasilnya di sini.
Contoh 4:
Selepas memasukkan fail pengepala dan 'ruang nama std', kami mengisytiharkan kelas 'MyNewStudent' di sini. Fungsi ahli ” studentPass()” ialah salah satu fungsi ahli yang kami bina untuk kelas “MyStudentClass” yang kami jana di sini. Kami juga menambah 'cout' pada fungsi ini yang akan menyebabkan apabila kami memanggilnya dalam kod kami.
Seterusnya, kami menulis fungsi ahli 'studentFail()' di mana kami menggunakan 'cout' sekali lagi. Fungsi main() kemudiannya dipanggil dan penunjuk fungsi ahli “(MyNewStudent::*studentResultFunc)()” diisytiharkan. Di bawah itu, kami menjana objek ” myStd_obj ” yang tergolong dalam kelas “MyNewStudent”.
Seterusnya, kami menetapkan fungsi 'studentPass' kepada penunjuk 'studentResultFunc'. Di bawah itu, kami memanggil fungsi ini dengan menghantar nama objek bersama-sama dengan rujukan 'studentResultFunc'. Fungsi 'studentFail' ditetapkan semula kepada penunjuk ' studentResultFunc '. Di bawah itu, kami menggunakan kaedah ini dengan memberikan rujukan 'carEngineFunc' dan nama objek.
Sekarang, kedua-dua fungsi dipanggil di sini dan pernyataan yang kami sertakan dalam fungsi ini diberikan.
Kod 4:
#includemenggunakan ruang nama std ;
kelas MyNewStudent {
awam :
batal studentPass ( ) {
cout << 'Pas pelajar' << endl ;
}
batal pelajarGagal ( ) {
cout << 'Pelajar itu gagal' << endl ;
}
} ;
int utama ( ) {
batal ( MyNewStudent ::* studentResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
studentResultFunc = & MyNewStudent :: studentPass ;
( myStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = & MyNewStudent :: pelajarGagal ;
( myStd_obj. * studentResultFunc ) ( ) ;
kembali 0 ;
}
Pengeluaran:
Kami mencipta fungsi ahli dalam kod kami dan kemudian penunjuk fungsi ahli. Selepas ini, kami memanggil fungsi ahli dan memaparkan hasilnya di sini.
Contoh 5:
'SampleClass' dicipta dalam keadaan ini. Kemudian, penunjuk fungsi ahli diletakkan di sini iaitu '(SampleClass::*MyFunc)()'. Di bawah ini, kami mencipta penunjuk fungsi iaitu '(*MyFuncPtr)()'. Di bawahnya, kami mengisytiharkan 'nama' pembolehubah 'rentetan' serta penunjuk fungsi ahli 'MyFunc f'.
Selepas ini, kami mempunyai pembina 'awam' di mana kami mentakrifkan pembolehubah fungsi ahli ini. Di bawah ini, kami mencipta fungsi ahli bernama 'myFunc_1()' dan 'myFunc_1()' dan juga menambah 'cout' dalam setiap fungsi ahli yang akan dipaparkan apabila kami memanggil fungsi ahli ini.
Kemudian, kami memanggil penunjuk fungsi ahli ini dengan bantuan '(this->*f)()'. Kemudian, kami meletakkan fungsi sekali lagi. Di sini, kami menukar pernyataan 'cout' yang kami tambahkan sebelum ini. Kemudian, 'main()' kini digunakan dan penuding fungsi ahli ditakrifkan sebagai 'MyFunc f = &SampleClass::myFunc_2'.
Kemudian, penunjuk fungsi juga ditakrifkan sebagai 'MyFuncPtr fp = myFunc_1'. Selepas ini, kami menaip '(a.*f)()' untuk menggunakan penuding fungsi ahli. 'b.func' diletakkan untuk menggunakan fungsi ahli. Kemudian, kami meletakkan 'fp()' untuk memanggil penuding fungsi.
Kod 5:
#includemenggunakan ruang nama std ;
kelas SampleClass ;
typedef batal ( SampleClass ::* MyFunc ) ( ) ;
typedef batal ( * MyFuncPtr ) ( ) ;
kelas SampleClass {
nama rentetan ;
MyFunc f ;
awam :
SampleClass ( const char * nama )
: nama ( nama ) ,
f ( & SampleClass :: myFunc_1 )
{ }
batal myFunc_1 ( ) { cout << nama << 'Kami memanggil fuction 1 di sini' << endl ; }
batal myFunc_2 ( ) { cout << nama << 'Kami memanggil fungsi 2 di sini' << endl ; }
batal fungsi ( ) {
( ini ->* f ) ( ) ;
}
} ;
batal myFunc_1 ( ) { cout << 'Fungsi pertama' << endl ; }
batal myFunc_2 ( ) { cout << 'Fungsi kedua' << endl ; }
int utama ( )
{
MyFunc f = & SampleClass :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
Kelas Sampel a ( 'pertama-' ) , b ( 'kedua-' ) ;
( a. * f ) ( ) ;
b. fungsi ( ) ;
fp ( ) ;
}
Pengeluaran:
Hasil kod kini dipaparkan di sini yang menjadikan hasilnya sewajarnya seperti yang kami panggil fungsi dalam kod kami.
Kesimpulan
Kami meneroka bahawa 'penunjuk fungsi ahli' dalam C++ memudahkan pengikatan dinamik, enkapsulasi tingkah laku dan pengendalian yang fleksibel bagi seruan fungsi dalam konteks OOP. Kami mengetahui bahawa penggunaan 'penunjuk fungsi ahli' boleh meningkatkan modulariti dan fleksibiliti pangkalan kod C++ dengan ketara, menyediakan alat yang berkuasa untuk menangani pelbagai reka bentuk dan cabaran masa jalan.