Bagaimana cara mengatasi saling ketergantungan kelas dalam kode C ++ saya?

Dalam proyek C ++ saya, saya punya dua kelas, Particledan Contact. Di Particlekelas, saya memiliki variabel anggota std::vector<Contact> contactsyang berisi semua kontak dari suatu Particleobjek, dan fungsi anggota yang sesuai getContacts()dan addContact(Contact cont). Jadi, dalam "Particle.h", saya memasukkan "Contact.h".

Di Contactkelas, saya ingin menambahkan kode ke konstruktor untuk Contactpanggilan itu Particle::addContact(Contact cont), sehingga contactsdiperbarui untuk kedua Particleobjek di mana Contactobjek ditambahkan. Jadi, saya harus memasukkan "Particle.h" dalam "Contact.cpp".

Pertanyaan saya adalah apakah ini dapat diterima / praktik pengkodean yang baik dan, jika tidak, apa yang akan menjadi cara yang lebih baik untuk mengimplementasikan apa yang saya coba capai (sederhananya, secara otomatis memperbarui daftar kontak untuk partikel tertentu setiap kali kontak baru dibuat).

Kelas-kelas ini akan diikat bersama oleh Networkkelas yang akan memiliki N partikel ( std::vector<Particle> particles) dan kontak Nc ( std::vector<Contact> contacts). Tapi saya ingin dapat memiliki fungsi seperti particles[0].getContacts()- apakah boleh memiliki fungsi seperti itu di Particlekelas dalam kasus ini, atau apakah ada asosiasi "struktur" yang lebih baik di C ++ untuk tujuan ini (dari dua kelas terkait yang digunakan di kelas lain) .

Saya mungkin perlu perubahan perspektif di sini tentang bagaimana saya mendekati ini. Karena dua kelas dihubungkan oleh Networkobjek kelas, apakah itu kode / kelas organisasi yang khas untuk memiliki informasi konektivitas sepenuhnya dikendalikan oleh Networkobjek (di mana objek partikel tidak harus menyadari kontaknya dan, akibatnya, seharusnya tidak memiliki getContacts()anggota fungsi). Kemudian, untuk mengetahui kontak apa yang dimiliki partikel tertentu, saya perlu mendapatkan informasi itu melalui Networkobjek (misalnya, menggunakan network.getContacts(Particle particle)).

Apakah itu kurang khas (bahkan mungkin berkecil hati) desain kelas C ++ untuk objek Partikel untuk memiliki pengetahuan itu, juga (yaitu, memiliki beberapa cara untuk mengakses informasi itu - baik melalui objek Jaringan atau objek Partikel, mana yang tampaknya lebih nyaman )?

Ada dua bagian dalam pertanyaan Anda.

Bagian pertama adalah organisasi file header C ++ dan file sumber. Ini dipecahkan dengan menggunakan deklarasi maju dan pemisahan deklarasi kelas (meletakkannya di file header) dan metode tubuh (meletakkannya di file sumber). Lebih jauh lagi, dalam beberapa kasus seseorang dapat menerapkan idiom Pimpl ("pointer ke implementasi") untuk menyelesaikan kasus yang lebih sulit. Gunakan pointer kepemilikan bersama ( shared_ptr), pointer kepemilikan tunggal ( unique_ptr), dan pointer tidak memiliki (pointer mentah, yaitu "tanda bintang") sesuai dengan praktik terbaik.

Bagian kedua adalah bagaimana memodelkan objek yang saling terkait dalam bentuk grafik . Grafik umum yang bukan DAG (grafik asiklik langsung) tidak memiliki cara alami untuk mengekspresikan kepemilikan seperti pohon. Sebagai gantinya, semua node dan koneksi adalah metadata yang dimiliki oleh objek grafik tunggal. Dalam hal ini, tidak mungkin untuk memodelkan hubungan simpul-koneksi sebagai agregasi. Node tidak memiliki "koneksi"; koneksi tidak "memiliki" node. Sebaliknya, mereka adalah asosiasi, dan kedua node dan koneksi "dimiliki oleh" grafik. Grafik menyediakan metode kueri dan manipulasi yang beroperasi pada node dan koneksi.

Jika saya membuat Anda benar, objek kontak yang sama milik lebih dari satu objek partikel, karena itu mewakili semacam kontak fisik antara dua atau lebih partikel, kan?

Jadi hal pertama yang menurut saya patut dipertanyakan adalah mengapa Particlememiliki variabel anggota std::vector<Contact>? Seharusnya a std::vector<Contact*>atau std::vector<std::shared_ptr<Contact> >sebaliknya. addContactmaka harus memiliki tanda tangan berbeda seperti addContact(Contact *cont)atau addContact(std::shared_ptr<Contact> cont)sebagai gantinya.

Ini membuatnya tidak perlu untuk memasukkan "Contact.h" dalam "Particle.h", sebuah deklarasi maju class Contactdalam "Particle.h", dan menyertakan "Contact.h" dalam "Particle.cpp" sudah cukup.

Lalu pertanyaan tentang konstruktor. Anda menginginkan sesuatu seperti

 Contact(Particle &p1, Particle &p2)
 {
      p1.addContact(this);
      p2.addContact(this);
 }

Baik? Desain ini ok, asalkan program Anda selalu mengetahui partikel terkait pada titik waktu ketika objek kontak harus dibuat.

Catatan, jika Anda pergi std::vector<Contact*>rute, Anda harus menginvestasikan beberapa pemikiran tentang masa hidup dan kepemilikan Contactobjek. Tidak ada partikel "memiliki" kontaknya, kontak mungkin harus dihapus hanya jika kedua Particleobjek terkait dihancurkan. std::shared_ptr<Contact>Sebaliknya, menggunakan akan menyelesaikan masalah ini untuk Anda secara otomatis. Atau Anda membiarkan objek "konteks sekitarnya" mengambil kepemilikan partikel dan kontak (seperti yang disarankan oleh @rwong), dan mengelola masa pakainya.

Ya, apa yang Anda gambarkan adalah cara yang dapat diterima untuk memastikan bahwa setiap Contactinstance ada dalam daftar kontak a Particle.

Apa yang Anda lakukan benar.

Cara lain ... Jika tujuannya adalah untuk memastikan bahwa setiap orang Contactada dalam daftar, maka Anda dapat:

• blokir penciptaan Contact (konstruktor pribadi),
• maju menyatakan Particle kelas,
• Jadikan Particlekelas temanContact ,
• dalam Particlemembuat metode pabrik yang membuat aContact

Maka Anda tidak harus menyertakan particle.hdicontact

Opsi lain yang mungkin Anda pertimbangkan adalah membuat konstruktor Kontak yang menerima referensi Partikel templated. Ini akan memungkinkan Kontak untuk menambahkan dirinya sendiri ke wadah apa pun yang mengimplementasikan addContact(Contact).

template<class Container>
Contact(/*parameters*/, Container& container)
{
  container.addContact(*this);
}