The use of double include guards in C++

Question

So I recently had a discussion where I work, in which I was questioning the use of a double include guard over a single guard. What I mean by double guard is as follows:

Header file, "header_a.hpp":

#ifndef __HEADER_A_HPP__ #define __HEADER_A_HPP__ ... ... #endif 

When including the header file anywhere, either in a header or source file:

#ifndef __HEADER_A_HPP__ #include "header_a.hpp" #endif 

Now I understand that the use of the guard in header files is to prevent multiple inclusion of an already defined header file, it's common and well documented. If the macro is already defined, the entire header file is seen as 'blank' by the compiler and the double inclusion is prevented. Simple enough.

The issue I don't understand is using #ifndef __HEADER_A_HPP__ and #endif around the #include "header_a.hpp". I'm told by the coworker that this adds a second layer of protection to inclusions but I fail to see how that second layer is even useful if the first layer absolutely does the job (or does it?).

The only benefit I can come up with is that it outright stops the linker from bothering to find the file. Is this meant to improve compilation time (which was not mentioned as a benefit), or is there something else at work here that I am not seeing?

Answer 1

I am pretty sure that it is a bad practice to add another include guard like:

#ifndef __HEADER_A_HPP__ #include "header_a.hpp" #endif 

Here are some reasons why:

1. To avoid double inclusion it is enough to add a usual include guard inside the header file itself. It does the job well. Another include guard in the place of inclusion just messes the code and reduces readability.

2. It adds unnecessary dependencies. If you change include guard inside the header file you have to change it in all places where the header is included.

3. It is definitely not the most expensive operation comparing the whole compilation/linkage process so it can hardly reduce the total build time.

4. Any compiler worth anything already optimizes file-wide include-guards.