c++ header files including each other mutually

You shouldn't include the header files inside the other ones, just include the header files in your source files.

In the headers you can use a forward declaration:

// In Class1.h
class Class2;

// In class2.h
class Class1;

Also you can protect against a file being included twice using the preprocessor:

// Class1.h
#ifndef __CLASS_1_H
#define __CLASS_1_H

// content

#endif

I know this is an old topic but maybe you are still interested in solution!

Actually in C++ you can use two classes recursively without using pointers and here is how to do it.

file: a.h

#include <b.h>

class A {
    B<> b;
}

file: b.h

class A;

template<typename T = A>
class B {
    T a;
}

file: main.cpp

#include "a.h"    
A a;

and that's all!

of course this is just for curiosity :)

You cannot have each class have "a field that is type of other class"; that would be a recursive definition and not only the compiler would not be able to make any sense out of it, it does not even make logical sense.

Each class having a field that is type of the other class is the kind of impossibility that you only see in M.C. Escher drawings, or animations thereof, like this one:

 

                                           

                 B. de Smit and H. W. Lenstra - Source: escherdroste.math.leidenuniv.nl

                     based on Escher's "Print Gallery" Lithograph, 1956, see Wikipedia

 

One of the two fields will have to be a pointer, so as to break the recursive containment, and avoid the logical impossibility.

Which brings us to the next problem: if class B is to contain an instance of class A, then obviously, A has to be declared before class B, so that A is already known to the compiler when compiling B. But if class A is declared before class B, how can we declare a pointer to B in A? Class B is not known yet at the time that A is compiled! The answer to this is a special construct known as forward declaration which exists precisely in order to accommodate situations like this. A forward declaration of class B looks like this:

class B;

All it is telling the compiler is that there will be a class called B. It does not tell the compiler anything about the contents of class B, so there is very little we can do with it, but we can do one thing: declare pointers to B.

So, the full solution to the problem looks like this:

file "A.h":

/* This is called a "forward declaration".  We use it to tell the compiler that
   the identifier "B" will from now on stand for a class, and this class will be
   defined later.  We will not be able to make any use of "B" before it has been
   defined, but we will at least be able to declare pointers to it. */
class B;

class A
{
    /* We cannot have a field of type "B" here, because it has not yet been
       defined. However, with the forward declaration we have told the compiler
       that "B" is a class, so we can at least have a field which is a pointer 
       to "B". */
    B* pb; 
}

file "B.h":

#include "A.h"

class B
{
   /* the compiler now knows the size of "A", so we can have a field
      of type "A". */
   A a;
}