İki sınıf arasında çoktan çoğa ilişkiyi temsil etmenin iyi bir yolu nedir?

Diyelim ki A ve B olmak üzere iki nesne tipim var. Aralarındaki ilişki çoktan çoğa, ama ikisi de diğerinin sahibi değil.

A ve B örneklerinin her ikisi de bağlantının farkında olmalıdır; bu sadece bir yol değil.

Yani, bunu yapabiliriz:

class A
{
    ...

    private: std::vector<B *> Bs;
}

class B
{
    private: std::vector<A *> As;
}

Sorum şu: bağlantıları oluşturmak ve yok etmek için fonksiyonları nereye koyabilirim?

A :: Bs ve B :: vektör olarak güncellenen A :: Ek (B) olmalı mı?

Ya da eşit derecede makul görünen B :: Attach (A) olmalı.

Bunların hiçbiri doğru hissetmiyor. Kodla çalışmayı bırakırsam ve bir hafta sonra geri gelirsem, A.Attach (B) veya B.Attach (A) yapmam gerektiğini hatırlayamayacağımdan eminim.

Belki de böyle bir işlev olmalıdır:

CreateConnection(A, B);

Ancak, sadece A ve B sınıflarıyla çalışmak için bir işlev olduğu için, küresel bir işlev yapmak da istenmeyen bir durumdur.

Başka bir soru: sık sık bu sorun / gereksinim ile karşılaşırsam, bir şekilde genel bir çözüm yapabilir miyim? Belki de türetebileceğim veya bu tür bir ilişkiyi paylaşan sınıflar içinde kullanabileceğim bir TwoWayConnection sınıfı?

Bu durumla başa çıkmanın bazı iyi yolları nelerdir ... Bire-çok "C'nin D sahibi" durumunun oldukça iyi nasıl idare edileceğini biliyorum, ama bu daha zor.

Edit: Sadece daha açık yapmak için, bu soru sahiplik sorunları içermez. Hem A hem de B başka bir Z nesnesine aittir ve Z tüm sahiplik sorunlarını ele alır. Sadece A ve B arasındaki çoktan çoğa bağlantıları nasıl oluşturacağım / kaldıracağım.

Bunun bir yolu, her sınıfa bir genel Attach()yöntem ve korumalı bir AttachWithoutReciprocating()yöntem eklemektir . Make Ave Bonların böylece ortak arkadaşlarımız Attach()yöntemleri diğer 's çağırabilir AttachWithoutReciprocating():

A::Attach(B &b) {
    Bs.push_back(&b);
    b.AttachWithoutReciprocating(*this);
}

A::AttachWithoutReciprocating(B &b) {
    Bs.push_back(&b);
}

Benzer yöntemleri uygularsanız Bhangi sınıfı arayacağınızı hatırlamanız gerekmez Attach().

Eminim bir o davranışı sarabilirdiniz olduğum MutuallyAttachablesınıfın her iki Ave Bmiras böylece kendini tekrar ve Hesap Günü bonus puan puanlama kaçınarak dan. Ancak her iki yerde de sofistike olmayan uygulama yöntemi bile işi halledecek.

İlişkinin kendisinin ek özelliklere sahip olması mümkün müdür ?

Eğer öyleyse, o zaman ayrı bir sınıf olmalıdır.

Değilse, herhangi bir ileri geri hareketli liste yönetim mekanizması yeterli olacaktır.

Genellikle garip hissettiren bu tür durumlara girdiğimde, nedenini tam olarak söyleyemiyorum, çünkü yanlış bir sınıfa bir şey koymaya çalışıyorum. Neredeyse her zaman bazı işlevleri sınıftan çıkarmanın Ave Bişleri daha net hale getirmenin bir yolu vardır .

İlişkilendirmeyi taşımaya aday olanlardan biri, ilişkilendirmeyi ilk etapta oluşturan koddur. Belki çağırmak yerine attach()sadece bir listesini saklar std::pair<A, B>. İlişkilendirmeler oluşturan birden fazla yer varsa, bir sınıfa ayrılabilir.

Bir hamle için başka bir aday Zda sizin durumunuzda ilişkili nesnelere sahip olan nesnedir .

İlişkilendirmeyi taşımak için kullanılan bir diğer yaygın aday da, yöntemleri veya nesneleri sık sık çağıran koddur . Örneğin, tüm ilişkili nesnelerle dahili olarak bir şeyler yapan çağrı yerine, her biri için ilişkilendirmeleri ve çağrıları zaten biliyor . Yine, birden fazla yer onu çağırırsa, tek bir sınıfa soyutlanabilir.ABa->foo()Ba->foo(b)

İlişkilendirmeyi oluşturan, sahip olan ve kullanan nesnelerin çoğu kez aynı nesne olur. Bu, yeniden düzenlemeyi çok kolaylaştırabilir.

Son yöntem, ilişkiyi diğer ilişkilerden türetmektir. Örneğin, kardeşler çoktan çoğa bir ilişkidir, ancak kardeş sınıfında kız kardeşlerin bir listesini tutmak yerine tam tersi, bu ilişkiyi ebeveyn ilişkisinden alırsınız. Bu yöntemin diğer avantajı, tek bir gerçek kaynağı yaratmasıdır. Bir hata veya çalışma zamanı hatasının kardeş, kız kardeş ve ebeveyn listeleri arasında tutarsızlık yaratmasının olası bir yolu yoktur, çünkü yalnızca bir listeye sahipsiniz.

Bu tür yeniden düzenleme, her seferinde işe yarayan sihirli bir formül değildir. Her bir durum için iyi bir uyum bulana kadar denemeniz gerekiyor, ancak zamanın yaklaşık% 95'inde işe yaradığını buldum. Kalan zamanlar sadece beceriksizlikle yaşamak zorundasın.

Bunu uyguluyor olsaydım, Attach yönteminin her ikisine de Attach yönteminin içine Attach koyardım, daha sonra iletilen nesneye Attach'ı çağırırdım. A). Sözdizim doğru olmayabilir, yıllardır c ++ kullanmadım:

class A {
  private: std::vector<B *> Bs;

  void Attach (B* obj) {
    // Only add obj if it's not in the vector
    if (std::find(Bs.begin(), Bs.end(), obj) == Bs.end()) {
      //Add obj to the vector
      Bs.push_back(obj);

      // Attach this class to obj
      obj->Attach(this);
    }
  }    
}

class B {
  private: std::vector<A *> As;

  void Attach (A* obj) {
    // Only add obj if it's not in the vector
    if (std::find(As.begin(), As.end(), obj) == As.end()) {
      //Add obj to the vector
      As.push_back(obj);

      // Attach this class to obj
      obj->Attach(this);
    }
  }    
}

Alternatif bir yöntem, AB eşleşmelerinin statik bir listesini yöneten 3. sınıf bir C oluşturmaktır.