Two way reference between classes - How to avoid them knowing each other?

Question

Imagine having multiple classes deriving from one base class. All classes need to know each other, which is not an option, since it's a bit larger project I'm working at. I'm going to use a made-up inventory - item relation as an example due to it's simplicity.

class Inventory : public Base {
    std::vector<Base*> m_items; // These CAN be Items
};

class Item : public Base {
    Base* m_parent; // This CAN be Inventory
};

These two classes are obviously in different files and they will need to use each others methods, which their base class doesn't have. Notice the word CAN, not MUST, meaning that the m_parent and m_items can be objects of any class derived from Base. So Item's parent could be either Inventory or TreasureChest.

tl;dr Two classes must be able to communicate with each other, without knowing each others' type. How, and what, would be the best way to implement such an activity?

Answer 1

One way would be to define an abstract function for the type of communication in the Base class. Then implement this function in your derived classes. This allows you to handle the kind of communication for each type you need.

But with two way reference you have to be more cautions about deleting such objects. This type of architecture is very error prone.

For two way references with communication could look like: base.h:

class Base {
  void doCommunication(Base *caller) = 0;
};

Inventory.h:

class Inventory;      // forward declaration for Item class
#include "Item.h"

class Inventory : public Base {
   void doCommunication(Base *commCaller) { 
      // check type
      Inventory *invCaller = dynamic_class<Inventory*> (commCaller);
      if(invCaller != nullptr) {
         // called from inventory and you are able to use inventory

         return;  // you can stop here cause commCaller can only be Base class instead but not Item
      }

      Item *itemCaller = dynamic_class<Inventory*> (commCaller);
      if(invCaller != nullptr) {
         // called from item and you are able to use item

         return;  // you can stop here cause commCaller can only be Base class instead but not inventory
      }
   }
};

the Item.h looks pretty similar to inventory class, the doCommunications has to be overided for the item specific functionalities.

i cant test the code yet, but it should work. Cause of dynamic_cast you are able to cast to the destination object you need and call the needed functions. If it fails you get an nullptr.

Hope it helps.

cheers Lukas

Answer 2

In your example there isn't any actual problem: There is no immediate dependency between the two classes and you didn't show any part of the implementation. In case the implementation actually needs to access specific Inventory and Item method from the respective other class, the way to go is to factor each set of operations into a respective base class, possibly also deriving from Base and providing suitable functions.

For example

// base.h
class Base {
public:
    virtual ~Base();
};

// abstractitem.h
class AbstractItem: public Base {
public:
    virtual int weight() const = 0;
};

// abstractinventory.h
class AbstractInventory: public Base {
public:
    virtual int totalWeight() const = 0;
};

// item.h
class Item: public AbstractItem {
public:
    int weight() const;
    // uses of AbstractInventory
};

// inventory.h
class Inventory: public AbstractInventory {
    void addItem(AbstractItem const* item);
    int totalWeight() const;
    // uses of AbstractItem
};

Note that the abstract and independent operations of inventory and item are just factored out. There isn't any dependency between the interface or the implementation although the concrete objects will actually be able to call each other.

Answer 3

Two classes can "know each other" just fine. Just only forward declare referenced class in the header file of its user, and only include the referenced class header in the cpp (not the h)...

A.h:

struct B; // fwd decl

struct A
{
    B* b;

    void fa();
};

A.cpp:

#include "A.h"
#include "B.h"

void A::fa() { b->fb(); }

B.h:

struct A; // fwd decl

struct B
{
    A* a;

    void fb();
};

B.cpp:

#include "B.h"
#include "A.h"

void B::fb() { a->fa(); }

This is obviously an infinite runtime loop, but you get the point.