Question

The facts:

• I have two predominant classes: Manager and Specialist.
• There are several different types of Specialists.
• Specialists often require the help of other Specialists in order to get their job done.
• The Manager knows all of the Specialists, and initially each Specialist knows only their Manager. (This is the problem.)
• At runtime, the Manager creates and stores a list of Specialists. Then the Manager iterates through the list and asks each Specialist to initialize. During their initialization, each Specialist asks the Manager to supply them with other Specialists that fulfill some description. Once this is complete, the Manager then goes into a loop during which the Specialists are asked sequentially to perform their specialized task.

To me it seems that this is a decent pattern, but since a Manager has a list of Specialists and a Specialist has a Manager I’m getting circular dependency problems.

Is this a case where I should somehow forward declare the existence of one class from another? (If so, how?) Or should I use some design pattern to fix this problem? (If so what?) Also… I though the pattern itself was pretty o.k. so I wouldn’t mind someone helping me understand why this is a bad thing.

Answer 1

In both cases, forward declare the other class:

Manager.h

class Specialist;

class Manager
{
    std::list<Specialist*> m_specialists;
};

Specialist.h

class Manager;

class Specialist
{
    Manager* m_myManager;
};

The only time you need to bring in the header file for a class is when you need to use a member function or variable within that class, or need to use the class as a value type etc. When you only need a pointer or reference to a class, a forward declaration will suffice.

Note that forward declarations aren’t just for solving circular dependencies. You should use forward declarations wherever possible. They are always preferable to including an extra header file if it is at all viable.