How to Prevent Duplicate Header Inclusion in C/C++: #ifndef vs #pragma once

Problem with repeated header inclusion

When a source file includes the same header multiple times, the preprocessor copies the header contents each time, causing duplicate definitions of classes, functions, or variables and violating the One Definition Rule. Example:

// math.h
class Math {
public:
    int add(int a, int b);
    int subtract(int a, int b);
};

// main.cpp
#include "math.h"
#include "math.h" // duplicate include
int main() {
    Math m;
    return 0;
}

Result: error: redefinition of 'class Math'

Header guard using #ifndef

Wrap the header content with a unique macro.

// math.h
#ifndef MATH_H
#define MATH_H

class Math {
public:
    int add(int a, int b);
    int subtract(int a, int b);
};

#endif // MATH_H

The macro is defined on the first inclusion; subsequent includes skip the body, preventing duplicate definitions.

Header guard using #pragma once

Place a single directive at the top of the header.

// math.h
#pragma once

class Math {
public:
    int add(int a, int b);
    int subtract(int a, int b);
};

The compiler ensures the file is processed only once.

Comparison

#ifndef : Standard C/C++ preprocessor directive, supported by all compilers. Requires three lines and a unique macro name.

#pragma once : Concise one‑line directive, typically faster because the compiler handles inclusion directly, and avoids macro name collisions. May not be supported by very old compilers.

Both techniques effectively prevent duplicate header inclusion; choose the one that best fits your project's portability and compiler support requirements.