Difference between include directive and forward declaration in C++

Question

I must refactor an old code. One of its problems is that it exceeds on useless 'includes'. In the same project, I've seen the following syntax:

#include <AnyClass> //A system header
#include "AnotherAnyClass" //A application header

class AnotherClass;

class Class : public OneMoreClass
{

public:
    explicit Class();
    ~Class();

private:
    AnotherClass *m_anotherClass;

}

I'd like to figure out:

What are the differences between a 'include "Class"' and a 'class Class'?
When should the second method be used and how?

@Cthulhu To nitpick, it's a declaration, not a definition. :) — JBL, Oct 23 '14 at 14:26
They are entirely different things! No comparison to be made. — Lightness Races in Orbit, Oct 23 '14 at 14:31

score 7 · Answer 1 · answered Oct 23 '14 at 14:07

7

Declaring a class like this:

class AnotherClass;

is called a Forward Declaration. It lets the compiler know about the existence of the class, in situations where knowning the details about the class aren't needed, like in the scenario you posted.

Generally if you aren't going to be using an instance of the class, you're just dealing with a pointer and not calling any methods on it, you don't need to know anything more than the class name. This can speed up compilation in large projects.

answered Oct 23 '14 at 14:07

Nick Veys

23,458
4
47
64

2

You didn't explain how this differs from `#include`. – Lightness Races in Orbit Oct 23 '14 at 14:32
@LightnessRacesinOrbit It depends on what is in the included file. If all that is in the included file is `class AnotherClass;`, then there is no difference:-). – James Kanze Oct 23 '14 at 15:57
@JamesKanze: Which should be part of the answer! :) – Lightness Races in Orbit Oct 23 '14 at 16:04

JBL · Answer 2 · 2014-10-23T14:57:58.947

To understand the difference, you must understand why the compiler need the include in the first place.

The compiler must know the size of each class you declare. Thus it has to know the size of each member you added to the class. In the case of a non-pointer non-built-in member, the compiler has to see the definition of that member class, which is usually in a header that you must include. In the case of a pointer though, the compiler doesn't have to see the whole definition because whatever its type, a pointer is always of the same size on a given platform (usually 32 or 64 bits). So when the member is a pointer, the compiler only has to know the name, which can be done through forward declaration, i.e.

class AnotherClass;

Now, which one to use?

Keeping it short: Use forward declaration when you can, include when you must.

If your header can do fine with a forward declaration, you'll decrease your overall compilation time, because each header you include will have to be processed in every translation unit that contains it.

A common scheme is to forward declare in the header, and include the corresponding class in the associated .cpp.

Thans JBL. Very good! Now I understand why my compiler is showing error when I try replicate this syntax in a code that does use a instance of the class instead a pointer to it. — crissilvaeng, Oct 23 '14 at 14:31
"In the case of a non-pointer"... did you mean the compiler must first see a *definition* of the class? — Ben Voigt, Oct 23 '14 at 14:56

score 5 · Accepted Answer · answered Oct 23 '14 at 14:24

Those are two different things:

#include <AnyClass>

this is a normal include for a header (or any type of textual) file. It is equivalent to pasting the content of the AnyClass file in the spot where you typed that inclusion directive (that's why include guards and/or compiler pragmas are often used to prevent multiple inclusions in the same file).

This syntax:

class AnotherClass;

is a forward declaration and it informs the compiler of the existence of AnotherClass class. It is useful in many scenarios, for e.g. suppose you have two classes where each one needs a pointer to the other:

class ClassB {
    ClassA* pointer_to_classA;
};
class ClassA {
    ClassB* pointer_to_classB;
};

the above code will generate an error: "error: unknown type name 'ClassA'" since you used a ClassA type without the compiler knowing what it is (yet). The compiler's parser only get to know ClassA's existence when it parses the beginning of the class declaration.

To have the above working you need a forward declaration:

class ClassA; // A ClassA type exists

class ClassB {
    ClassA* pointer_to_classA;
};
class ClassA {
    ClassB* pointer_to_classB;
};

Marco A., thanks for the answer and the examples. I really understand your explanation. — crissilvaeng, Oct 23 '14 at 14:40
Just one slight point: `#include ` is for including a system header; it might not be a file, and it might not look anywhere but standard places. For headers from the application, he should use `#include "AnyClass.hh"`. (He shouldn't use files without extensions either.) — James Kanze, Oct 23 '14 at 15:56
That's right! In my code `#include ` is a class of Qt Framework. — crissilvaeng, Oct 23 '14 at 16:52

Difference between include directive and forward declaration in C++

3 Answers3