An interesting simple code of forward declaration

There are 2 classes, A and B:

Code:

---------------------------------
FileA.h
---------------------------------
#include <FileB.h>
class B; //Why forward declaration here
class A{
...
B objB;
...
};
---------------------------------
FileA.cc
---------------------------------
#include <FileA.h>
...implementation of class A...




---------------------------------
FileB.h
---------------------------------
class A; //  I understand this is forward declaration 
class B{
...
A objA;
...
};

---------------------------------
FileB.cc
---------------------------------
...Implementation of class B

What I don't understand is that why forward declare class B in FileA.h? Seems FileA.h already included FileB.h.

You're right, it wouldn't technically be required to have that forward declaration, because including FileA.h would result in the following code:

Code:

class A; //  I understand this is forward declaration 
class B{
...
A objA;
...
};

class B; //Why forward declaration here
class A{
...
B objB;
...
};

However, spurious forward declarations never hurt anyone (that I've ever heard of). It might at least make it clearer to the reader that B is a class, without them having to delve into FileB.h to find out.

Note that your example is a little off, since the forward declaration of A in FileB.h is not enough to have a member variable of type A inside B.

One possible reason for this in real code would be if the programmer was afraid of recursive includes. However, if a forward declaration is good enough with the #include, then the #include should be removed anyway, and if it is not, then it won't help in a situation of recursive includes, so I would argue it isn't a good idea anyway.

Hi, Daved. I don't quite understand you. Why "forward declaration of A in FileB.h is not enough to have a member variable of type A inside B." But the code can run correctly, can't it?

If all the compiler has of a class (or structure) is a forward declaration, you can't declare an instance of that class. The best you can do is to declare a pointer to it.

Imagine what could happen otherwise.

Code:

class two;
class one { two t; };
class two { one o; };

int main() {}

Oops. Dinkumware's online compiler complains with

Code:

sourceFile.cpp(2) : error C2079: 'one::t' uses undefined class 'two'

dwks explained what I was referring to. In your example, class B has a member of type A, but if a cpp file includes FileB.h without including FileA.h before it, then the compiler won't have enough information about A to compile B properly.

No matter how the includes are done, your example cannot compile anyway. The class B has a member of type A, so to know how big B is the compiler needs to know how big A is. But A has a member of type B, so to know how big A is the compiler needs to know how big B is. But B has a member of type A... and so on.

If you have a pointer or reference to A in B (or B in A), then it is fine, because the compiler doesn't need to know the size of A, it just needs the size of a pointer or reference and a forward declaration will do.