包含声明之外的包含防护

Question

I recently started working on a project where I came across this:

#include <string.h> // includes before include guards
#include "whatever.h"

#ifndef CLASSNAME_H // header guards
#define CLASSNAME_H
// The code
#endif

My question: Considering all (included) header files were written in that same style: Could this lead to problems (cyclic reference, etc.). And: Is there any (good) reason to do this?

Answer 1

Potentially, having #include outside the include guards could lead to circular references, etc. If the other files are properly protected, there isn't an issue. If the other files are written like this one, there could be problems.

No, there isn't a good reason that I know of to write the code with the #include lines outside the include guards.

The include guards should be around the whole contents of the header; I can't think of an exception to this (when header guards are appropriate in the first place — the C header <assert.h> is one which does not have header guards for a good reason).

Answer 2

As long as you don't have circular includes ( whatever1.h includes whatever2.h which includes whatever1.h ) this should not be a problem, as the code itself is still protected against multiple inclusion.

It will however almost certainly impact compile time (how much depends on the project size) for two reasons:

1. Modern compilers usually detect "classical" include guards and just ignore any further #includes of that file (just like #pragma once ). The structure you are showing prevents that optimization.
2. Each compilation unit becomes much larger as each file will be included much more often - right before the preprocessor then deletes all the inactive blocks again.

In any case, I can't think of any benefit such a structure would have. Maybe it is the result of some strange historical reasons, like some obscure analysis tool that was used on your codebase in pre-standard C++ time.