Contoh 1:
Kami menyertakan file header “iostream” untuk memudahkan penggunaan fungsi yang ditentukan. Kemudian, kita memiliki 'namespace std'. Di bawahnya, kami membuat kelas bernama “MyNewClass” dan menggunakan konstruktor “publik”.
Di “publik”, kita membuat fungsi anggota bernama “myFunc” dan mendeklarasikan “int num” sebagai parameter “myFunc()”. Di bawah ini, kita menggunakan 'cout' dan memanggil metode main() di bawahnya di mana kita membuat penunjuk fungsi anggota. Kami mendeklarasikan penunjuk “MyFuncPtr” ke tipe fungsi anggota, menentukan kelas “MyNewClass” dan tipe parameter (int).
Setelah ini, kita membuat objek kelas bernama “Class_obj” dan kemudian memanggil fungsi anggota dengan bantuan pointer “*MyFuncPtr” dengan menempatkan objek kelas dengan ini. Kami menetapkan '10' sebagai parameter untuk merender ini ketika kami memanggil penunjuk fungsi anggota.
Kode 1:
#termasukmenggunakan namespace std ;
kelas Kelas Baru Saya {
publik :
ruang kosong fungsi saya ( ke dalam pada satu ) {
cout << 'Nilainya adalah' << pada satu << akhir ;
}
} ;
ke dalam utama ( ) {
ruang kosong ( Kelas Baru Saya ::* Fungsi SayaPtr ) ( ke dalam ) = & Kelas Baru Saya :: fungsi saya ;
Kelas Baru Saya Kelas_obj ;
( Kelas_obj. * Fungsi SayaPtr ) ( 10 ) ;
kembali 0 ;
}
Keluaran:
Hal ini menggambarkan cara kerja pointer fungsi anggota. Penunjuk fungsi anggota dapat digunakan untuk meluncurkan fungsi anggota secara dinamis sesuai dengan kondisi saat ini.
Contoh 2:
Untuk menggunakan fungsi yang didefinisikan dalam file header “iostream” secara sederhana, kami menyertakan “iostream” di sini. “Namespace std” ditempatkan berikutnya. Di bawahnya, kita membuat kelas “Test” dan kemudian menggunakan konstruktor “publik”. Kami mendefinisikan fungsi anggota ' myTestingFunc ' di 'publik' dan menetapkan 'int t_value' sebagai parameter untuk ' myTestingFunc()' dalam contoh ini. Fungsi “cout” digunakan di bawah dan metode main() dipanggil. Kemudian, kita membuat penunjuk fungsi anggota.
Kami menentukan kelas “Test” dan penunjuk fungsi anggota “*MyTestFuncPtr” di sini. Kami menetapkan “&Test::myTestingFunc” ke penunjuk fungsi anggota yang dideklarasikan sebagai “void (Test::*MyTestFuncPtr)(int)”.
Selanjutnya, kita membuat objek kelas “t_obj” dan menggunakannya untuk memanggil fungsi anggota dengan meletakkan objek kelas dan menggunakan penunjuk “*MyTestFuncPtr”. Agar hal ini ditampilkan saat kita memanggil penunjuk fungsi anggota, kita menetapkan “932” sebagai parameternya.
Kode 2:
#termasukmenggunakan namespace std ;
Tes kelas {
publik :
ruang kosong myTestingFunc ( ke dalam nilai_t ) {
cout << 'Nilai pengujiannya adalah' << nilai_t << akhir ;
}
} ;
ke dalam utama ( ) {
ruang kosong ( Tes ::* MyTestFuncPtr ) ( ke dalam ) = & Tes :: myTestingFunc ;
Uji t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
kembali 0 ;
}
Keluaran:
Hasil dari kode yang diberikan diberikan. Kita dapat melihat bahwa kita memanggil “penunjuk fungsi anggota” dengan objek kelas seperti yang ditunjukkan di sini.
Contoh 3:
Kelas yang kita hasilkan dalam kode ini adalah “MyNewCar” di mana kita menggunakan konstruktor “publik” dan membuat fungsi anggota di dalamnya yaitu “startCarEngine()”. Dalam fungsi ini, kita menambahkan “cout” yang ditampilkan ketika kita memanggil fungsi ini dalam kode kita. Kemudian, kita membuat fungsi anggota lainnya yaitu “stopCarEngine()” dan menggunakan “cout” lagi di fungsi anggota ini.
Setelah ini, kita memanggil fungsi main() dan kemudian mendeklarasikan penunjuk fungsi anggota yaitu “MyNewCar::*carEngineFunc()”. Di bawahnya, kita membuat objek kelas “MyNewCar” dengan nama, “myCar_obj”. Kemudian, kami menetapkan fungsi “startCarEngine” ke penunjuk “carEngineFunc”. Di bawahnya, kita memanggil fungsi ini dengan bantuan penunjuk “carEngineFunc” dengan menempatkan nama objek di dalamnya.
Selanjutnya, kami menetapkan kembali fungsi “stopCarEngine” ke penunjuk “carEngineFunc”. Di bawahnya, kita memanggil fungsi ini dengan meneruskan nama objek bersama dengan referensi “carEngineFunc”.
Kode 3:
#termasukmenggunakan namespace std ;
kelas MyNewCar {
publik :
ruang kosong mulaiCarEngine ( ) {
cout << 'Mesin mobil menyala' << akhir ;
}
ruang kosong hentikanCarEngine ( ) {
cout << 'Mesin mobil berhenti' << akhir ;
}
} ;
ke dalam utama ( ) {
ruang kosong ( Mobil baruku ::* carEngineFunc ) ( ) ;
Mobil Baru Saya Mobil_obj ;
carEngineFunc = & Mobil baruku :: mulaiCarEngine ;
( mobil_obj saya. * carEngineFunc ) ( ) ;
carEngineFunc = & Mobil baruku :: hentikanCarEngine ;
( mobil_obj saya. * carEngineFunc ) ( ) ;
kembali 0 ;
}
Keluaran:
Di sini, cara kerja “penunjuk fungsi anggota” ditampilkan. Kita dapat melihat bahwa kita membuat penunjuk fungsi anggota dan menampilkan hasilnya di sini.
Contoh 4:
Setelah menyertakan file header dan “namespace std”, kami mendeklarasikan kelas “MyNewStudent” di sini. Fungsi anggota ” studentPass()” adalah salah satu fungsi anggota yang kami buat untuk kelas “MyStudentClass” yang kami hasilkan di sini. Kami juga menambahkan 'cout' ke fungsi ini yang akan dirender saat kami memanggilnya dalam kode kami.
Selanjutnya, kita menulis fungsi anggota “studentFail()” di mana kita menggunakan “cout” sekali lagi. Fungsi main() kemudian dipanggil dan penunjuk fungsi anggota “(MyNewStudent::*studentResultFunc)()” dideklarasikan. Di bawahnya, kita membuat objek “myStd_obj” yang termasuk dalam kelas “MyNewStudent”.
Selanjutnya, kami menetapkan fungsi “studentPass” ke penunjuk “studentResultFunc”. Di bawahnya, kita memanggil fungsi ini dengan meneruskan nama objek bersama dengan referensi “studentResultFunc”. Fungsi “studentFail” dipindahkan ke penunjuk “studentResultFunc”. Di bawahnya, kami memanggil metode ini dengan memberikan referensi “carEngineFunc” dan nama objek.
Sekarang, kedua fungsi dipanggil di sini dan pernyataan yang kami sertakan dalam fungsi ini dirender.
Kode 4:
#termasukmenggunakan namespace std ;
kelas Siswa Baru Saya {
publik :
ruang kosong pass pelajar ( ) {
cout << 'Kartu pelajar' << akhir ;
}
ruang kosong siswaGagal ( ) {
cout << 'Siswa gagal' << akhir ;
}
} ;
ke dalam utama ( ) {
ruang kosong ( Siswa Baru Saya ::* studentResultFunc ) ( ) ;
Siswa Baru Saya myStd_obj ;
studentResultFunc = & Siswa Baru Saya :: pass pelajar ;
( myStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = & Siswa Baru Saya :: siswaGagal ;
( myStd_obj. * studentResultFunc ) ( ) ;
kembali 0 ;
}
Keluaran:
Kami membuat fungsi anggota dalam kode kami dan kemudian penunjuk fungsi anggota. Setelah ini, kami memanggil fungsi anggota dan menampilkan hasilnya di sini.
Contoh 5:
'SampleClass' dibuat dalam contoh ini. Kemudian, penunjuk fungsi anggota ditempatkan di sini yaitu “(SampleClass::*MyFunc)()”. Di bawahnya, kita membuat penunjuk fungsi yaitu “(*MyFuncPtr)()”. Di bawahnya, kami mendeklarasikan “nama” variabel “string” serta penunjuk fungsi anggota “MyFunc f”.
Setelah ini, kita memiliki konstruktor “publik” tempat kita mendefinisikan variabel fungsi anggota ini. Di bawahnya, kita membuat fungsi anggota bernama “myFunc_1()” dan “myFunc_1()” dan juga menambahkan “cout” di setiap fungsi anggota yang akan ditampilkan saat kita memanggil fungsi anggota ini.
Kemudian, kita memanggil penunjuk fungsi anggota ini dengan bantuan “(ini->*f)()”. Lalu, kita tempatkan kembali fungsinya. Di sini, kami mengubah pernyataan “cout” yang kami tambahkan sebelumnya. Kemudian, “main()” sekarang dipanggil dan penunjuk fungsi anggota didefinisikan sebagai “MyFunc f = &SampleClass::myFunc_2”.
Kemudian, penunjuk fungsi juga didefinisikan sebagai “MyFuncPtr fp = myFunc_1”. Setelah ini, kita mengetik “(a.*f)()” untuk memanfaatkan penunjuk fungsi anggota. 'B.func' ditempatkan untuk memanfaatkan fungsi anggota. Kemudian, kita tempatkan “fp()” untuk memanggil penunjuk fungsi.
Kode 5:
#termasukmenggunakan namespace std ;
kelas Kelas Sampel ;
typedef ruang kosong ( Kelas Sampel ::* Fungsi Saya ) ( ) ;
typedef ruang kosong ( * Fungsi SayaPtr ) ( ) ;
kelas Kelas Sampel {
nama string ;
Fungsi Saya f ;
publik :
Kelas Sampel ( konstanta arang * nama )
: nama ( nama ) ,
F ( & Kelas Sampel :: fungsi saya_1 )
{ }
ruang kosong fungsi saya_1 ( ) { cout << nama << 'Kami memanggil fungsi 1 di sini' << akhir ; }
ruang kosong fungsi saya_2 ( ) { cout << nama << 'Kami memanggil fungsi 2 di sini' << akhir ; }
ruang kosong fungsi ( ) {
( ini ->* F ) ( ) ;
}
} ;
ruang kosong fungsi saya_1 ( ) { cout << 'Fungsi pertama' << akhir ; }
ruang kosong fungsi saya_2 ( ) { cout << 'Fungsi kedua' << akhir ; }
ke dalam utama ( )
{
Fungsi Saya f = & Kelas Sampel :: fungsi saya_2 ;
MyFuncPtr fp = fungsi saya_1 ;
Kelas Sampel a ( 'Pertama - ' ) , B ( 'Kedua - ' ) ;
( A. * F ) ( ) ;
B. fungsi ( ) ;
fp ( ) ;
}
Keluaran:
Hasil dari kode sekarang dirender di sini yang merender hasilnya sesuai dengan apa yang kita sebut fungsi dalam kode kita.
Kesimpulan
Kami mengeksplorasi bahwa 'penunjuk fungsi anggota' di C++ memudahkan pengikatan dinamis, enkapsulasi perilaku, dan penanganan pemanggilan fungsi yang fleksibel dalam konteks OOP. Kami mempelajari bahwa penggunaan “penunjuk fungsi anggota” dapat secara signifikan meningkatkan modularitas dan fleksibilitas basis kode C++, menyediakan alat yang ampuh untuk mengatasi berbagai tantangan desain dan waktu proses.