Resolve build errors due to circular dependency amongst classes

Question

I often find myself in a situation where I am facing multiple compilation linker errors in a C   project due to some bad design decisions  made by someone else      which lead to circular dependencies between C   classes in different header files  can happen also in the same file   But fortunately    this doesn t happen often enough for me to remember the solution to this problem for the next time it happens again   So for the purposes of easy recall in the future I am going to post a representative problem and a solution along with it  Better solutions are of-course welcome      A h  class B  class A       int  val      B   b  public       A int val            val val                   void SetB B  b                 b   b           b- gt Print       COMPILER ERROR  C2027  use of undefined type  B             void Print                 cout lt  lt  Type A val   lt  lt  val lt  lt endl                 B h   include  A h  class B       double  val      A   a  public       B double val            val val                   void SetA A  a                 a   a           a- gt Print               void Print                 cout lt  lt  Type B val   lt  lt  val lt  lt endl                 main cpp   include  B h   include  lt iostream gt   int main int argc  char  argv          A a 10       B b 3 14       a Print        a SetB  amp b       b Print        b SetA  amp a       return 0

User · Answer

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;
}

User · Answer

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- gt Print               void Print                 cout lt  lt  Type A val   lt  lt  val lt  lt 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- gt Print               void Print                 cout lt  lt  Type B val   lt  lt  val lt  lt endl              main cpp  include  lt iostream gt   include  A h   include  B h   int main int argc  char  argv          A a 10       B b 3 14       a Print        a SetB  amp b       b Print        b SetA  amp a       return 0

User · Answer

Unfortunately I can t comment the answer from geza   He is not just saying  put forward declarations into a separate header   He says that you have to spilt class definition headers and inline function definitions into different header files to allow  defered dependencies    But his illustration is not really good  Because both classes  A and B  only need an incomplete type of each other  pointer fields   parameters    To understand it better imagine that class A has a field of type B not B   In addition class A and B want to define an inline function with parameters of the other type   This simple code would not work      A h  pragme once  include  B h   class A    B b    inline void Do B b      inline void A  Do B b       do something with B       B h  pragme once class A   class B    A  b    inline void Do A a       include  A h   inline void B  Do A a       do something with A      main cpp  include  A h   include  B h     It would result in the following code     main cpp    include  A h   class A   class B    A  b    inline void Do A a      inline void B  Do A a       do something with A    class A    B b    inline void Do B b      inline void A  Do B b       do something with B      include  B h     This code does not compile because B  Do needs a complete type of A which is defined later   To make sure that it compiles the source code should look like this     main cpp class A   class B    A  b    inline void Do A a      class A    B b    inline void Do B b      inline void B  Do A a       do something with A    inline void A  Do B b       do something with B      This is exactly possible with these two header files for each class wich needs to define inline functions  The only issue is that the circular classes can t just include the  public header    To solve this issue I would like to suggest a preprocessor extension   pragma process pending includes  This directive should defer the processing of the current file and complete all pending includes

User · Answer

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

User · Answer

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- gt Print       inline void A  Print         cout lt  lt  Type A val   lt  lt  val lt  lt 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- gt Print       inline void B  Print         cout lt  lt  Type B val   lt  lt  val lt  lt 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

User · Answer

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  lt iosfwd gt  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  lt typename T gt  class Basic B  typedef Basic B lt char gt  B    b h   template  lt typename T gt  class Basic B          class definition       typedef Basic B lt char gt  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

User · Answer

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  lt iostream gt   using namespace std   A  A int val    val val       void A  SetB B  b         b   b      cout lt  lt  Inside SetB    lt  lt endl       b- gt Print       void A  Print         cout lt  lt  Type A val   lt  lt  val lt  lt endl       B cpp  include  B h   include  A h   include  lt iostream gt   using namespace std   B  B double val    val val       void B  SetA A  a         a   a      cout lt  lt  Inside SetA    lt  lt endl       a- gt Print       void B  Print         cout lt  lt  Type B val   lt  lt  val lt  lt 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  amp b       b Print        b SetA  amp a       return 0

User · Answer

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- gt Print       inline void A  Print         cout lt  lt  Type A val   lt  lt  val lt  lt endl      endif      A H           and doing the same in B h

User · Answer

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

User · Answer

The way to think about this is to  think like a compiler    Imagine you are writing a compiler  And you see code like this      file  A h class A     B  b         file  B h class B     A  a         file main cc  include  A h   include  B h  int main          A a      When you are compiling the  cc file  remember that the  cc and not the  h is the unit of compilation   you need to allocate space for object A  So  well  how much space then  Enough to store B  What s the size of B then  Enough to store A  Oops   Clearly a circular reference that you must break   You can break it by allowing the compiler to instead reserve as much space as it knows about upfront - pointers and references  for example  will always be 32 or 64 bits  depending on the architecture  and so if you replaced  either one  by a pointer or reference  things would be great  Let s say we replace in A      file  A h class A        both these are fine  so are various const versions of the same    B amp   b ref    B   b ptr       Now things are better  Somewhat  main   still says      file  main cc  include  A h       lt -- Houston  we have a problem    include  for all extents and purposes  if you take the preprocessor out  just copies the file into the  cc  So really  the  cc looks like      file  partially pre processed main cc class A     B amp   b ref    B   b ptr      include  B h  int main           A a      You can see why the compiler can t deal with this - it has no idea what B is - it has never even seen the symbol before   So let s tell the compiler about B  This is known as a forward declaration  and is discussed further in this answer      main cc class B   include  A h   include  B h  int main           A a      This works  It is not great  But at this point you should have an understanding of the circular reference problem and what we did to  fix  it  albeit the fix is bad   The reason this fix is bad is because the next person to  include  A h  will have to declare B before they can use it and will get a terrible  include error  So let s move the declaration into A h itself      file  A h class B  class A     B   b     or any of the other variants       And in B h  at this point  you can just  include  A h  directly      file  B h  include  A h  class B        note that this is cool because the compiler knows by this time      how much space A will need    A  a       HTH

User · Answer

In some cases it is possible to define a method or a constructor of class B in the header file of class A to resolve circular dependencies involving definitions  In this way you can avoid having to put definitions in  cc files  for example if you want to implement a header only library      file  a h  include  b h  struct A     A const B amp  b     b b        B get     return  b      B  b         note that the get method of class B is defined in a h A B  get       return A  this         file  b h class A  struct B        here the get method is only declared   A get           file  main cc  include  a h  int main          B b    A a   b get

[c++] Resolve build errors due to circular dependency amongst classes

Examples related to c++

Examples related to compiler-errors

Examples related to circular-dependency

Examples related to c++-faq