In the C and C++ programming languages, an #include guard, sometimes called a macro guard, header guard or file guard, is a way to avoid the problem of double inclusion when dealing with the include directive.
The C preprocessor processes inclusion directives like <code>#include "Foo.h"</code> to include "Foo.h" and transcludes the code of that file into a copy of the main file often called the translation unit.
However, if an #include directive for a given file appears multiple times during compilation, the code will effectively be duplicated in that file. If the included file includes a definition, this can cause a compilation error due to the One Definition Rule, which says that definitions (such as the definition of a class) cannot be duplicated in a translation unit. #include guards prevent this by defining a preprocessor macro when a header is first included. In the event that header file is included a second time, the #include guard will prevent the actual code within that header from being compiled.
An alternative to #include guards is #pragma once. This non-standard but commonly supported directive among C and C++ compilers has the same purpose as an #include guard, but has less code and does not require the definition of a variable.
Modules, introduced in C++20, eliminate the necessity of <code>#include</code> guards, due to not being handled by the preprocessor. Modules can only be imported at most one time into a translation unit.
The following C code demonstrates a real problem that can arise if #include guards are missing:
Here, the file "Child.c" has indirectly included two copies of the text in the header file "Grandparent.h". This causes a compilation error, since the structure type <code>Foo</code> will thus be defined twice. In C++, this would be called a violation of the one definition rule.
The same code as the previous section is used with the addition of #include guards. The C preprocessor preprocesses the header files, including and further preprocessing them recursively. This will result in a working source file.
Here, the first inclusion of "Grandparent.h" has the macro <code>GRANDPARENT_H</code> defined. When "Child.c" includes "Grandparent.h" at the second time (while including "Parent.h"), as the <code>#ifndef</code> test returns false, the preprocessor skips down to the <code>#endif</code>, thus avoiding the second definition of <code>struct Foo</code>. The program compiles correctly.
Different naming conventions for the guard macro may be used by different programmers. Other common forms of the above example include <code>GRANDPARENT_INCLUDED</code>, <code>CREATORSNAME_YYYYMMDD_HHMMSS</code> (with the appropriate time information substituted), and names generated from a UUID. (However, names starting with one underscore and a capital letter (C and C++) or any name containing double underscore (C++ only), such as <code>_GRANDPARENT_H</code> and <code>GRANDPARENT__H</code>, are reserved to the language implementation and should not be used by the user.)
Of course, it is important to avoid duplicating the same include-guard macro name in different header files, as including the 1st will prevent the 2nd from being included, leading to the loss of any declarations, inline definitions, or other #includes in the 2nd header.
For #include guards to work properly, each guard must test and conditionally set a different preprocessor macro. Therefore, a project using #include guards must work out a coherent naming scheme for its include guards, and make sure its scheme doesn't conflict with that of any third-party headers it uses, or with the names of any globally visible macros.
For this reason, most C and C++ implementations provide a non-standard <code>#pragma once</code> directive. This directive, inserted at the top of a header file, will ensure that the file is included only once. The Objective-C language (which is a superset of C) has an <code>#import</code> directive, which works exactly like <code>#include</code>, except that it includes each file only once, thus obviating the need for #include guards.
Some languages support specifying that the code should be included only once, in the including file, rather than in the included one (as with C/C++ include guards and <code>#pragma once</code>):