Circular dependencies in c++

Question

Say I have these two classes:

// a.h

#include "b.h"

and:

// b.h

include "a.h"

I understand there is a problem over here, but how can I fix it and use a objects and their methods in b class and vice versa?

The Ghost of StackOverflow says, "*Uhhhhhhnnnn... Neeeeed moooore cooooode......*" — Mateen Ulhaq, Sep 10 '11 at 22:30

score 2 · Accepted Answer · edited May 23 '17 at 12:29

2

You can use forward declarations, like this:

class B;

class A
{
    B* ThisIsValid;
}

class B
{
    A SoIsThis;
}

For more information, see this SO question.

As for the preprocessor #includes, there's likely a better way to organize your code. Without the full story, though, it's hard to say.

edited May 23 '17 at 12:29

Community

1
1

answered Sep 10 '11 at 22:33

Maxpm

22,560
30
103
164

1

I've seen it where the simplest model was forward declaring it in the header files. – Joshua Sep 10 '11 at 22:37

score 1 · Answer 2 · answered Sep 10 '11 at 22:45

To extend on @Borealid 's answer:

To avoid problems with circular includes, using an "include guard"

eg.

#ifndef MYFILE_H /* If this is not defined yet, it must be the first time
 we include this file */
#define MYFILE_H // Mark this file as already included
// This only works if the symbol we are defining is unique.

// code goes here

#endif

score 0 · Answer 3 · answered Sep 10 '11 at 22:33

0

You can use what is called a "forward declaration".

For a function, this would be something like void myFunction(int);. For a variable, it might look like extern int myVariable;. For a class, class MyClass;. These bodiless statements can be included before the actual code-bearing declarations, and provide the compiler with enough information to produce code making use of the declared types.

To avoid problems with circular includes, using an "include guard" - an #ifdef at the top of each header file which prevents it being included twice.

answered Sep 10 '11 at 22:33

Borealid

91,119
8
102
121

This answer doesn't discuss the real core of the thing, which is that you restrict your mention of `B` in `A`'s header to forward declarable things, but in `A`'s source file you are free to `#include` the full definition because nothing is going to `#include` the source file... you're not going to have any circular dependencies with it. This _only_ affects headers, and that's how we can make use of an approach that effectively cripples use of a type. – Lightness Races in Orbit Sep 10 '11 at 22:37

score 0 · Answer 4 · answered Sep 10 '11 at 22:37

The "other" class can only have a reference or pointer to the "first" class.

in file a.h:

#include "b.h"

struct a {
    b m_b;
};

in file b.h:

struct a;

struct b {
    a* m_a;
};

void using_the_a_instance(b& theb);

in file b.cpp:

#include "b.h"
#include "a.h"

void using_the_a_instance(b& theb)
{
    theb.m_a = new a();
}

Circular dependencies in c++

4 Answers4