Tukukkk

You can avoid compilation errors if you remove the method definitions from the header files and let the classes contain only the method declarations and variable declarations/definitions. The method definitions should be placed in a .cpp file (just like a best practice guideline says).

The down side of the following solution is (assuming that you had placed the methods in the header file to inline them) that the methods are no longer inlined by the compiler and trying to use the inline keyword produces linker errors.

//A.h

#ifndef A_H

#define A_H

class B;

class A

{

    int _val;

    B* _b;

public:



    A(int val);

    void SetB(B *b);

    void Print();

};

#endif



//B.h

#ifndef B_H

#define B_H

class A;

class B

{

    double _val;

    A* _a;

public:



    B(double val);

    void SetA(A *a);

    void Print();

};

#endif



//A.cpp

#include "A.h"

#include "B.h"



#include <iostream>



using namespace std;



A::A(int val)

:_val(val)

{

}



void A::SetB(B *b)

{

    _b = b;

    cout<<"Inside SetB()"<<endl;

    _b->Print();

}



void A::Print()

{

    cout<<"Type:A val="<<_val<<endl;

}



//B.cpp

#include "B.h"

#include "A.h"

#include <iostream>



using namespace std;



B::B(double val)

:_val(val)

{

}



void B::SetA(A *a)

{

    _a = a;

    cout<<"Inside SetA()"<<endl;

    _a->Print();

}



void B::Print()

{

    cout<<"Type:B val="<<_val<<endl;

}



//main.cpp

#include "A.h"

#include "B.h"



int main(int argc, char* argv)

{

    A a(10);

    B b(3.14);

    a.Print();

    a.SetB(&b);

    b.Print();

    b.SetA(&a);

    return 0;

}

Things to remember:

• This won't work if class A has an object of class B as a member or vice versa.


• Forward declaration is way to go.


• Order of declaration matters (which is why you are moving out the definitions).
  
  
  
  
  • If both classes call functions of the other, you have to move the definitions out.
  
  
  
  

Read the FAQ:

• How can I create two classes that both know about each other?


• What special considerations are needed when forward declarations are used with member objects?


• What special considerations are needed when forward declarations are used with inline functions?

I'm late answering this, but there's not one reasonable answer to date, despite being a popular question with highly upvoted answers....

Best practice: forward declaration headers

As illustrated by the Standard library's <iosfwd> header, the proper way to provide forward declarations for others is to have a forward declaration header. For example:

a.fwd.h:

#pragma once

class A;

a.h:

#pragma once

#include "a.fwd.h"

#include "b.fwd.h"



class A

{

  public:

    void f(B*);

};

b.fwd.h:

#pragma once

class B;

b.h:

#pragma once

#include "b.fwd.h"

#include "a.fwd.h"



class B

{

  public:

    void f(A*);

};

The maintainers of the A and B libraries should each be responsible for keeping their forward declaration headers in sync with their headers and implementation files, so - for example - if the maintainer of "B" comes along and rewrites the code to be...

b.fwd.h:

template <typename T> class Basic_B;

typedef Basic_B<char> B;

b.h:

template <typename T>

class Basic_B

{

    ...class definition...

};

typedef Basic_B<char> B;

...then recompilation of the code for "A" will be triggered by the changes to the included b.fwd.h and should complete cleanly.

Poor but common practice: forward declare stuff in other libs

Say - instead of using a forward declaration header as explained above - code in a.h or a.cc instead forward-declares class B; itself:

• if a.h or a.cc did include b.h later:
  
  
  
  
  • compilation of A will terminate with an error once it gets to the conflicting declaration/definition of B (i.e. the above change to B broke A and any other clients abusing forward declarations, instead of working transparently).
  
  
  
  


• otherwise (if A didn't eventually include b.h - possible if A just stores/passes around Bs by pointer and/or reference)
  
  
  
  
  • build tools relying on #include analysis and changed file timestamps won't rebuild A (and its further-dependent code) after the change to B, causing errors at link time or run time. If B is distributed as a runtime loaded DLL, code in "A" may fail to find the differently-mangled symbols at runtime, which may or may not be handled well enough to trigger orderly shutdown or acceptably reduced functionality.
  
  
  
  

If A's code has template specialisations / "traits" for the old B, they won't take effect.

I once solved this kind of problem by moving all inlines after the class definition and putting the #include for the other classes just before the inlines in the header file. This way one make sure all definitions+inlines are set prior the inlines are parsed.

Doing like this makes it possible to still have a bunch of inlines in both(or multiple) header files. But it's necessary to have include guards.

Like this

// File: A.h

#ifndef __A_H__

#define __A_H__

class B;

class A

{

    int _val;

    B *_b;

public:

    A(int val);

    void SetB(B *b);

    void Print();

};



// Including class B for inline usage here 

#include "B.h"



inline A::A(int val) : _val(val)

{

}



inline void A::SetB(B *b)

{

    _b = b;

    _b->Print();

}



inline void A::Print()

{

    cout<<"Type:A val="<<_val<<endl;

}



#endif /* __A_H__ */

...and doing the same in B.h

I've written a post about this once: Resolving circular dependencies in c++

The basic technique is to decouple the classes using interfaces. So in your case:

//Printer.h

class Printer {

public:

    virtual Print() = 0;

}



//A.h

#include "Printer.h"

class A: public Printer

{

    int _val;

    Printer *_b;

public:



    A(int val)

        :_val(val)

    {

    }



    void SetB(Printer *b)

    {

        _b = b;

        _b->Print();

    }



    void Print()

    {

        cout<<"Type:A val="<<_val<<endl;

    }

};



//B.h

#include "Printer.h"

class B: public Printer

{

    double _val;

    Printer* _a;

public:



    B(double val)

        :_val(val)

    {

    }



    void SetA(Printer *a)

    {

        _a = a;

        _a->Print();

    }



    void Print()

    {

        cout<<"Type:B val="<<_val<<endl;

    }

};



//main.cpp

#include <iostream>

#include "A.h"

#include "B.h"



int main(int argc, char* argv)

{

    A a(10);

    B b(3.14);

    a.Print();

    a.SetB(&b);

    b.Print();

    b.SetA(&a);

    return 0;

}

Here is the solution for templates: How to handle circular dependencies with templates

The clue to solving this problem is to declare both classes before providing the definitions (implementations). It’s not possible to split the declaration and definition into separate files, but you can structure them as if they were in separate files.

The simple example presented on Wikipedia worked for me.
(you can read the complete description at http://en.wikipedia.org/wiki/Circular_dependency#Example_of_circular_dependencies_in_C.2B.2B )

File '''a.h''':

#ifndef A_H

#define A_H



class B;    //forward declaration



class A {

public:

    B* b;

};

#endif //A_H

File '''b.h''':

#ifndef B_H

#define B_H



class A;    //forward declaration



class B {

public:

    A* a;

};

#endif //B_H

File '''main.cpp''':

#include "a.h"

#include "b.h"



int main() {

    A a;

    B b;

    a.b = &b;

    b.a = &a;

}

Unfortunately, all the previous answers are missing some details. The correct solution is a little bit cumbersome, but this is the only way to do it properly. And it scales easily, handles more complex dependencies as well.

Here's how you can do this, exactly retaining all the details, and usability:

• the solution is exactly the same as originally intended


• inline functions still inline


• users of A and B can include A.h and B.h in any order

Create two files, A_def.h, B_def.h. These will contain only A's and B's definition:

// A_def.h

#ifndef A_DEF_H

#define A_DEF_H



class B;

class A

{

    int _val;

    B *_b;



public:

    A(int val);

    void SetB(B *b);

    void Print();

};

#endif



// B_def.h

#ifndef B_DEF_H

#define B_DEF_H



class A;

class B

{

    double _val;

    A* _a;



public:

    B(double val);

    void SetA(A *a);

    void Print();

};

#endif

And then, A.h and B.h will contain this:

// A.h

#ifndef A_H

#define A_H



#include "A_def.h"

#include "B_def.h"



inline A::A(int val) :_val(val)

{

}



inline void A::SetB(B *b)

{

    _b = b;

    _b->Print();

}



inline void A::Print()

{

    cout<<"Type:A val="<<_val<<endl;

}



#endif



// B.h

#ifndef B_H

#define B_H



#include "A_def.h"

#include "B_def.h"



inline B::B(double val) :_val(val)

{

}



inline void B::SetA(A *a)

{

    _a = a;

    _a->Print();

}



inline void B::Print()

{

    cout<<"Type:B val="<<_val<<endl;

}



#endif

Note that A_def.h and B_def.h are "private" headers, users of A and B should not use them. The public header is A.h and B.h.