Desain: Memanggil kembali ke kelas induk

Ketika memodelkan suatu objek dengan anak-anak, biasanya memasukkan anak-anak melalui komposisi, sebagai anggota kelas induk. Namun terkadang anak-anak perlu memberi tahu orang tua sesuatu, mereka perlu memanggil fungsi orang tua. Bagaimana ini bisa dilakukan menggunakan C ++? Beberapa opsi adalah:

1. Jadikan kelas induk global karena itu objek anak akan dapat memanggil fungsi anggota dari objek induk.

2. Suntikkan objek induk sebagai, penunjuk atau referensi, ke setiap objek anak. Kemudian ketika anak perlu memberi tahu objek orang tua sesuatu, ia selalu dapat melakukannya karena ia memiliki variabel anggota yang dapat digunakan.

Apa metode lain untuk melakukan ini? Apakah ada pola desain umum atau nama untuk hal semacam ini?

Perhatikan bahwa saya tertarik pada ide dan solusi dalam C ++ karena detailnya akan berbeda dalam bahasa berorientasi objek lainnya. Misalnya poin 2 di atas menyebutkan 'pointer atau referensi' dan keduanya hanya mungkin dalam C ++. C ++ memiliki fitur bahasa yang tidak ada dalam bahasa lain sehingga implementasi solusi untuk masalah tersebut berpotensi menggabungkan fitur-fitur bahasa ini sehingga membuat solusi berbeda dari apa yang mungkin muncul dalam bahasa lain.

Hal pertama yang pertama, ini bisa menjadi bau kode. Inti dari menggunakan komposisi untuk orang tua / anak-anak adalah bahwa orang tua tahu tentang anak-anak tetapi tidak sebaliknya. Terutama jika hubungannya lebih dari 'mengandung' daripada 'terdiri dari'.

Referensi ke induk dimungkinkan dan cukup umum di C ++. Dalam bahasa lain, objek atau acara fungsi lebih sering digunakan untuk memungkinkan anak berkomunikasi hal-hal yang mungkin ingin diketahui orang luar. Ini adalah jenis pola publikasi-pelanggan yang umum. Saya menduga apa yang lebih idiomatis tergantung pada versi C ++ yang Anda gunakan dan standar basis kode Anda.

Seperti yang telah ditunjukkan orang lain, ide dasar untuk menyuntikkan objek induk sebagai pointer atau referensi adalah cara untuk pergi pada prinsipnya.

Ini memiliki satu kelemahan: Anda mendapatkan ketergantungan siklik antara orang tua dan anak. Jika Anda ingin menghindarinya, tentukan kelas dasar abstrak (antarmuka) IParentdari mana orang tua Anda mewarisi. IParentharus berisi metode sebagai fungsi virtual yang ingin dipanggil anak. Lalu, suntikkan induk sebagai referensi IParent. Ini membuat unit menguji anak jauh lebih mudah, karena sekarang Anda dapat dengan mudah mengganti objek induk dengan objek tiruan.

Jika anak Anda perlu memanggil hanya satu fungsi dari objek induk Anda, IParentkelas yang lengkap mungkin terlalu besar. Dalam hal ini, itu akan cukup untuk menyuntikkan pointer ke fungsi anggota ke dalam anak, atau objek functor merangkum fungsi anggota tersebut.

Yang dapat Anda lakukan adalah menyimpan referensi ke orang tua di kelas anak, dengan komposisi. Dengan begitu, si anak tahu orang tuanya dan bisa memohon metode publik padanya.

Jadi saya akan pergi dengan opsi 2. Anda harus berhati-hati, ketika seorang anak dihapus dari orang tua, Anda harus menghapus referensi ke orang tua pada anak dan arahkan ke nol (atau orangtua baru, jika ia memiliki satu). Atau Anda bisa menghapus objek anak, tergantung pada konteksnya.

Berikan mereka referensi atau pointer ke orang tua. Anda dapat menjadikan mereka teman dari orang tua, atau menjadikan metode yang disebut publik. Jika Anda tidak ingin melakukan salah satu di atas, Anda bisa memberikan mereka objek "jembatan" yang memperlihatkan salah satu metode induk sebagai publik dan itu sendiri merupakan kelas bersarang dari induk (oleh karena itu ia memiliki akses ke setiap metode induk ). Namun, ini bisa menjadi agak terlalu rumit dalam banyak situasi.

2) Suntikkan objek induk sebagai, pointer atau referensi, ke setiap objek anak. Kemudian ketika anak perlu memberi tahu objek orang tua sesuatu, ia selalu dapat melakukannya karena ia memiliki variabel anggota yang dapat digunakan.

Merupakan opsi yang sangat layak. Semua bahasa modern memiliki fitur yang dapat digunakan untuk merujuk ke bahasa lain.

Ada pendekatan serupa dengan sedikit variasi tetapi yang memberikan keuntungan:

Say Parent A berisi Komponen C.

Di Komponen C, deklarasikan InterfaceC dan tahan referensi untuk itu. Ini adalah antarmuka komponen dengan dunia luar.

Parent A mengimplementasikan InterfaceC, dan menetapkan referensi dalam Komponen C. Komponen C melihat Parent A sebagai InterfaceC.

Idenya adalah: Komponen berbicara ke luar menggunakan antarmuka.

Keuntungan menggunakan ini daripada menyetel induk secara langsung adalah:

Katakanlah komponen melakukan sesuatu dan perlu memberi tahu orang tua. Itu memanggil antarmuka. Kemudian, Anda memutuskan ingin mengubah induknya. Komponen tidak peduli sama sekali dan Anda tidak akan melakukan perubahan apa pun di dalamnya.

Katakan nanti Anda ingin memberi tahu banyak objek acara. Anda cukup membuat daftar InterfaceC dan menambahkan referensi ke dalamnya.

Kekurangan: Kelas induk pada akhirnya akan mengimplementasikan banyak antarmuka (saya pikir ini sebagai keuntungan, karena dengan melihat deklarasi kelas, saya langsung tahu siapa yang berbicara dengannya)

Perhatikan ini spesifik c #. Saya tidak tahu apakah c ++ memiliki sesuatu yang serupa.

Jika Anda memiliki formulir gui dengan tombol, Anda biasanya memiliki pendekatan yang berbeda menggunakan Peristiwa-Berlangganan juga dikenal sebagai Observer_pattern atau pola Publikasikan-berlangganan .

Tombol biasanya tidak tahu bentuk spesifik tempat tinggalnya. Alih-alih tombol memicu atau menerbitkan suatu acara dan formulir menerima pemberitahuan berlangganan dan dapat bereaksi sesuai.

Selain gui-s mekanisme ini dapat digunakan dalam setiap hubungan orangtua-anak