quote:Original post by OrangyTang

quote:Original post by Doc
You''re wasting your time. #ifndef... will always work, thus your #pragma once is redundant and pointless.

Include guards will always work and so are recommended, but adding #pragma is a good idea as well.

Include guards require the compiler to open the file, parse the guards, then skip over the contents. By comparison the #pragma method tells the compiler exactly what you want - that the file is to be included once and it does not need to be reopened.

This can have a significant improvement on compile times since less files need to be opened when not needed. By using both methods it is robust on different compilers (though the include guards) and faster to compile on those that support #pragma once.

That''s exactly what I meant (and wanted to say); thanks for supporting me.

---
shurcooL`

Here''s an excerpt from our intranet C++ coding guidelines on include guards:

----------------------------
External include guards exist to stop the pre-processor opening up Header.h, scanning the file in its entirety, and returning only to find that the file never needed to be opened in the first place. This can affect compile speeds dramatically.

It has been found that the use of #pragma once, on compilers that support it, does not replace the functionality of external include guards. Experiments with the latest VC7.1 compiler show that #pragma once is a lot slower than external include guards. See the following page for details of the experiment:

http://www.eskimo.com/~hottub/software/include/

The results obtained by putting #pragma once in the include guard test were as follows:

* External Include Guards: 0.08s
* Internal Include Guards: 6.25s
* No Include Guards: 9.70s

Note that external include guards are not needed when including from .cpp files.
----------------------------

Bottom line: #pragma once is useless.

Beside that point, there''s been interesting discussion on the gcc compiler mailing list about whether the person writing the header file should be allowed to dictate the use of their header file. This was the reason #pragma once or something similar was deprecated - gcc now handles all this automatically if you have include guards (I think, anyway).