Pragma once

This article has multiple issues. Please help improve it or discuss these issues on the talk page. It needs additional citations for verification. Tagged since November 2011. Its introduction provides insufficient context for those unfamiliar with the subject. Tagged since November 2011. It should be divided into sections by topic, to make it more accessible. Please help by adding section headings in accordance with Wikipedia's Manual of Style. Tagged since November 2011.

In the C and C++ programming languages, #pragma once is a non-standard but widely supported preprocessor directive designed to cause the current source file to be included only once in a single compilation. Thus, #pragma once serves the same purpose as #include guards, but with several advantages, including: less code, avoiding name clashes, and sometimes improved compile speed.^[1]

See the article on #include guards for an example of a situation in which one or the other of these methods must be used. The solution using include guards is given on that page; the #pragma once solution would be:

File "grandparent.h"

#pragma once
 
struct foo 
{
    int member;
};

File "parent.h"

#include "grandparent.h"

File "child.c"

#include "grandparent.h"
#include "parent.h"

Advantages and disadvantages

Using #pragma once instead of include guards will typically increase compilation speed since it is a higher-level mechanism; the compiler itself can compare filenames or inodes without having to invoke the C preprocessor to scan the header for #ifndef and #endif.

Some compilers such as GCC, Clang, and EDG-based compilers include special speedup code to recognize and optimize the handling of include guards, and thus little or no speedup benefit is obtained from the use of #pragma once.^[2][3]

Again because the compiler itself is responsible for handling #pragma once, it is not necessary for the programmer to create new macro names such as GRANDPARENT_H in the Include guard article's example. This eliminates the risk of name clashes, meaning that no header file can fail to be included at least once.

However, this high-level handling is not perfect; the programmer must rely on the compiler to handle #pragma once correctly. If the compiler makes a mistake, for example by failing to recognize that two symbolic links with different names point to the same file, then the compilation will fail. Compilers with #pragma once-related bugs included LCC-Win32 as of 2004^{[update] [4][5]} and GCC as of 1998^[update].^[6] GCC originally gave a warning declaring #pragma once "obsolete" when compiling code that used it. However, with the 3.4 release of GCC, the #pragma once handling code was fixed to behave correctly with symbolic and hard links. The feature was "un-deprecated" and the warning removed.^[7][8]

Both #pragma once and include guards can be used to write portable code that can also take advantage of #pragma once optimizations the compiler may support:

File "grandparent.h"

#pragma once
#ifndef GRANDPARENT_H
#define GRANDPARENT_H
 
struct foo
{
    int member;
};
 
#endif /* GRANDPARENT_H */

Portability

Notes

External links

• "Pragma Directives (C/C++)" at MSDN
• GCC Pragma and other commands at GNU Org