ansaurus

Question

What is the reason for #pragma once inside header guards?

Answer 1

A:

Yes header guards ensures that the header contents are included only once. but here you are using #pragma for checking another definition and not include file.

The below link is existing question on header guards in SO.

http://stackoverflow.com/questions/2979384/purpose-of-header-guards

ckv 2010-08-13 09:59:25

The header guard does this anyway, right? why need #pragma once as well?

MeThinks 2010-08-13 10:03:57

The header guard tells the preprocessor that it must silent all lines in the file from the `#ifndef` to the `#endif`, but the preprocessor is assumed to read the whole file, and just output no result for the block. The `#pragma once` tells the preprocessor that any later `#include` that contains the same file is to be ignored. The difference is that in the latter case the preprocessor will not even open the file and check. That being said, `#pragma once` is not standard, and compilers have grown to understand the include guard pattern and there should be not much of a difference.

David Rodríguez - dribeas 2010-08-13 10:08:37

@MeThinks - maybe not all implementations support this pragma, so you still want to prevent your header from being processed multiple times. The pragma is an added benefit here. (comment duplicated from another answer)

ysap 2010-08-13 10:09:32

Answer 2

+1 A:

Specifies that the file will be included (opened) only once by the compiler in a build. This can reduce build times as the compiler will not open and read the file after the first #include of the module

And one more related question from SO

DumbCoder 2010-08-13 10:00:20

Why the down vote ?

DumbCoder 2010-08-13 10:03:34

ok. I understand that purpose of header guards. Question is why we have header guard and pragma one

MeThinks 2010-08-13 10:04:36

@MeThinks - maybe not all implementations support this pragma, so you still want to prevent your header from being processed multiple times. The pragma is an added benefit here.

ysap 2010-08-13 10:08:19

A lot of it is answered in the SO link I gave in the answer.

DumbCoder 2010-08-13 10:09:37

Answer 3

+10 A:

#pragma once specifies that the file will be included (opened) only once by the compiler when compiling a source code file. This can reduce build times as the compiler will not open and read the file after the first #include of the module.

If you don't #pragma once, the file will be opened each time it is needed and compiler will stop parsing it on #ifndef BOOST_ASIO_HPP, if it has been defined.

AOI Karasu 2010-08-13 10:02:34

You saying the header is opened and read just the one time if we have #pragma? Header guards means file is always opened but contents within guards skipped, right? Is my understanding correct? If only I could demonstrate this so I see it happen :)

MeThinks 2010-08-13 10:09:04

In case of #pragma once it is not always opened. This directive makes the compiler remember not to open it again (more than once). That's why this directive is superior to #ifndef, which could be omitted. However many people still use #ifndef to support old compilers that do not recognize #pragma once.

AOI Karasu 2010-08-13 10:18:10

Answer 4

A:

#pragma once has the same purpose, but include guards are intended to require a deeper analysis to ensure a file is included exactly once - e.g.

// somerandomfileinmyproject.cpp
#undef BOOST_ASIO_HPP 
#include <bost/asio.cpp>

Unless the compiler does handle such cases correctly, it still needs to open the file and pass it through the preprocessor even though it has been included before.

peterchen 2010-08-13 10:16:04

Answer 5

A:

You can reproduce the effect of the #pragma once in a standard way using the following:

#if !defined GUARD_SYMBOL
#include "GUARDED_FILE"
#endif

although it is much more verbose. As others have said, it helps with compilation times since the file is not searched for / opened instead of opening the file and ignoring everything inside it - the file still has to be parsed by the preprocessor.

Skizz 2010-08-13 10:23:14

As David noted above, most modern compilers (esp. gcc) understands the header guard pattern well enough to skip the reparsing part, and act as if there was a pragma once or as if the code was written the way you show here.This, and the fact that pragma once cannot correctly handle some corner cases is also the reason why pragma once has been actively rejected from beeing introduced into the new C++0x standard. see also this [SO disscussion](http://stackoverflow.com/questions/787533/is-pragma-once-a-safe-include-guard)

Fabio Fracassi 2010-08-13 13:33:56

Answer 6

+1 A:

However it is not a C++ standard compliant way.

Chubsdad 2010-08-13 10:24:40

ansaurus

tags:

views:

answers:

What is the reason for #pragma once inside header guards?

related questions