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 #include "Foo.h" 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 #include 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 Foo 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.