Include Guards

Headers often include other headers. It is easy for one header to end up included twice in the same source file.

When that happens, every declaration in it appears twice. For type definitions like struct or typedef, that is a compile error: a type cannot be defined more than once.

Suppose a.h and b.h both include types.h. A source file that includes both ends up with types.h pasted in twice.

The preprocessor blindly copies header text, so types.h's definitions duplicate, triggering a redefinition error.

An include guard is a small preprocessor trick that makes a header safe to include many times.

It wraps the whole header in a conditional so the body is processed only the first time. Later inclusions are skipped entirely.

The first time the header is seen, TYPES_H is not defined, so #ifndef is true and the body is processed. The #define then sets the macro.

On any later inclusion, TYPES_H already exists, so #ifndef is false and the preprocessor skips to #endif.

Here is a realistic header with a guard protecting a type definition.

Even if many files include point.h directly or indirectly, the Point struct is defined exactly once per translation unit.

The guard macro must be unique across your whole project, or two headers could clash and silently hide each other.

A common convention derives the name from the filename in upper case: point.h becomes POINT_H, net/socket.h becomes NET_SOCKET_H.

Identifiers that begin with an underscore followed by a capital letter, or that contain double underscores, are reserved for the compiler and standard library.

Avoid guards like __POINT_H__. A plain trailing form such as POINT_H is safe and clear.

Most modern compilers support #pragma once, a single line at the top of a header that does the same job.

It is shorter and avoids naming clashes, but it is not part of the C standard. Traditional #ifndef guards work everywhere.

#ifndef guards are fully portable and standard, but require a unique macro per header.

#pragma once is compact and clash-free, but relies on compiler support. Some projects use both: a pragma plus a classic guard for maximum safety.

An include guard prevents duplicate inclusion within a single source file as it is compiled.

It does not prevent a header from being processed once in each separate .c file. That is fine, because each source file is a distinct translation unit.

Add an include guard to every header you write, from the very first line. It costs three lines and prevents a whole class of confusing errors.

Even simple headers can later be included indirectly through others, so guarding from the start saves trouble.

Check your grasp of include guards.

You learned why including a header twice causes redefinition errors and how an include guard prevents it.

Use #ifndef/#define/#endif with a unique macro, or #pragma once. Next we will look at sharing variables across files with extern.