Circular dependency on inheritance in C++

Question

I have already searched a lot on the web, but I haven't found anything that might solve my problem. I have these classes:

File: A.h

#include "B.h"

class A {
...
B method();
}

File: B.h

#include "A.h"

class B : public A {
...
}

I'm getting this error "expected class-name before ‘{’ token" in B class file. I've tried add the class declaration in A.h as well as in B.h, but nothing worked. I guess this is a circular dependency problem. Does anyone could help me?

Also, when I tried to forward the class declaration, I got: "invalid use of incomplete type..." — Lucas, Mar 16 '15 at 01:32
See this [answer](http://stackoverflow.com/questions/28697567/c-class-and-interlinked-objects-forming-a-cycle/28697923#28697923) — James Adkison, Mar 16 '15 at 01:35
It didn't work. Also, I need to use other A methods in B class. — Lucas, Mar 16 '15 at 02:25
In your real code does your base class (i.e., `A`) actually know about a derived type (i.e., `B`)? — James Adkison, Mar 16 '15 at 03:02

score 0 · Answer 1 · answered Mar 16 '15 at 01:55

This is called "forward declaration". For example:

#include "B.h"

class B;

class A {
...
B method();
};

As long as you only declare the method, and don't actually define it, this makes it possible to declare the method.

An actual C file will include both header files, and with the definitions of both classes, now the class method can be defined, or invoked and used.

You might want to start looking at the standard C++ headers like <iostream>, <string>, and others. All the templates in the C++ library typically have complex mutual dependencies on each others.

You will probably find that your C++ compiler has structured its headers in a fairly strict order. First come all the forward declarations and the class declarations. And only after everything is declared, only then you'll see the actual template declarations.

That's pretty much the only possible way it can be done.

No, I can't. When I remove it, the compiler says that B was not declared in this scope. — Lucas, Mar 16 '15 at 02:22

score 0 · Accepted Answer · edited May 23 '17 at 12:22

The following works for me. If you're still having problems you should provide an mvce.

Foo.h

#ifndef FOO_H
#define FOO_H

class Bar; // Forward declaration

// Note: I'm not sure why this interface knows anything about the derived type
class Foo
{
public:
    // Omitted the virtual destructor in this example

    Bar& try1();
    const Bar& try2() const;

    Bar try3() const;

    Bar* try4();
    const Bar* try5() const;
};

#endif

Foo.cpp

#include "Foo.h"

#include "Bar.h"

Bar& Foo::try1()
{
    return static_cast<Bar&>(*this);
}

const Bar& Foo::try2() const
{
    return static_cast<const Bar&>(*this);
}

Bar Foo::try3() const
{
    return Bar();
}

Bar* Foo::try4()
{
    return static_cast<Bar*>(this);
}

const Bar* Foo::try5() const
{
    return static_cast<const Bar*>(this);
}

Bar.h

#ifndef BAR_H
#define BAR_H

#include "Foo.h"

class Bar : public Foo
{
};

#endif

main.cpp

#include "Foo.h"
#include "Bar.h"

int main()
{
    Foo f;
    f.try1();
    f.try2();
    f.try3();
    f.try4();
    f.try5();

    return 0;
}

score 0 · Answer 3 · answered Mar 16 '15 at 05:33

There are a number of solutions to your problem but the best one is tailored to the design of your classes (which we don't know anything about). However, the following will resolve your problem, even if it doesn't follow an ideal design pattern:

Forward declare class B inside A.h and above class A definition.
Make sure you only use pointers or references to class B objects within A.h member function declarations.
Include B.h in A.cpp. NOTE the .cpp not .h

A.h

class B;

class A
{
public:
    A();
    ~A();

    B* method();
};

A.cpp

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

A::A()
{
}


A::~A()
{
}

B* A::method()
{
    return nullptr;
}

Please note there are virtues in only passing in, and returning, pointers / references to user defined types so this might not be a bad choice, particularly if you are only looking for a quick fix.

Circular dependency on inheritance in C++

3 Answers3

Foo.h

Foo.cpp

Bar.h

main.cpp