circular includes or something

I need a way to allow my program to do the following, but I can't seem to set things up (either in the includes or elsewhere) to allow it to do this:

foo.h

Code:

 
class Status{
 
  public:
    Status( bool status ) : m_status( status ) {}
    const bool getMStatus() const { return m_status; }
 
  private:
    bool m_status;
 
  friend Bar::Bar();
};
 
class Foo{
 
  public:
    Foo():fooStatus(0){}
    const bool getStatus() const { return fooStatus.getMStatus(); }
 
    Status& getStatusObject(){ return fooStatus; }
 
  private:
    Status fooStatus;
}

bar.h

Code:

class Bar{
 
  public:
    Bar() :{ mFoo.getStatusObject().m_status = 0; }
 
  private:
    Foo mFoo;
};

Problem is the compiler complains about "friend Bar::Bar()" because Bar hasn't been declared. I've tried adding both of these to the top of foo.h, but to no avail:

Code:

class Bar; // Compiler complains about no definition

Code:

#include "bar.h" // Compiler complains in bar.h that Foo isn't defined

Originally Posted by dudeomanodude

Problem is the compiler complains about "friend Bar::Bar()" because Bar hasn't been declared. I've tried adding both of these to the top of foo.h, but to no avail:

Code:

class Bar; // Compiler complains about no definition

The forward definition is insufficient, because you are declaring Bar::Bar() to be a friend, which requires knowledge of the inside of Bar. Instead of making just the constructor a friend, make the whole class Bar a friend, and the forward declaration should work.

hmm... I notice that at the moment friendship is entirely unnecessary: the default constructor of Foo does what the Bar default constructor is trying to do, namely, set m_status to false.