C++: How can 2 classes call each other without redeclaration and without headers calling each other

Question

I have a bit of problem with this. I have a class A which instantiates an object of B and then B which instantiates an object of A. Is this at all possible? I tried adding this in the headers of each

#ifndef A
#define A
  class a...
#endif

but if keeps me in an infinite header loop which it reaches the maximum header includes, so obviously one is calling the other and the other is calling that one. Is there any way to achieve this?

edit: Okay this seems like a good answer but now A complains that B doesn't have a Constructor despite the fact that it definitely has a constructor. I can't figure that one out.

Answer 1

You can forward declare the classes, for example:

A.h:

class B;

class A
{
    B* a_;
};

B.h:

class A;

class B
{
    A* a_;
};

In your source files where you actually use the classes (that is, create them, destroy them, use their members, etc.), you will need to include both headers so that their definitions are available:

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

Answer 2

Have you tried using forward declaration?

class B;

class A
{
  private:
     B* instanceOfB_;

};

Answer 3

You should break this circular dependence. For instance, you could use a pointer to B, and you could then forward declare the B class.

Answer 4

This is not a good design to start with. However to make it possible just use forward declaration.

In classA.h file remove any includes to classB.h and move them to the classA.cpp. Then before declaring classA write the line class B; to forward declare class B. This way you can have member variables of B* (but not B) inside class A. Do the same for classB next.

Answer 5

You can forward declare A in B's header file, and the other way around, to achieve what you want.

// In B.h
class A;

class B
{
  private:
    A a;
};

See Wikipedia for more information.

Answer 6

If you mean class A {B b;}; and class B {A a;}, no you can't. Class data members are included in the class, so you'd have a B that included an A that included a B that included an A.... Remember, in C++ a data object is not a reference to something, but is the actual thing.

You need something like class A {B * b;}; and class B {A * a;}, where you are providing pointers. Before the definitions, you need something like class A; class B; to tell the compiler that A and B are classes. These are called "forward declarations".

Answer 7

If you can, break the cyclic dependency. One idea is to use a mediator or a 3rd class.

class Mediator
{
// contains common functionality to A & B
// contains dependent functionality
};

class A : public Mediator;
class B : public Mediator;

As some experts say, 'All problems can be resolved with an additional layer of redirection."