include guards

[Aisthesis]

I've finally made it to the creation of classes, and my book (Gaddis) suggests as include guard only #ifndef ... #endif. But since I've seen #pragma once in various spots and it is used when MS Visual C++ generates an empty class, I looked that up in Wikipedia and learned that it's roughly equivalent to #ifndef ... #endif, saves a bit of space and has a few other advantages that I don't understand but also some disadvantages such as not being universally supported, possibly a bit more error-prone.

So, I just wanted to ask what more experienced programmers prefer as include guard when declaring classes.

[cpjust]

I always use:

#ifndef SOME_LONG_STRING
#define SOME_LONG_STRING
...
#endif // SOME_LONG_STRING

Since #pragma once is mostly a Microsoft thing, I just delete it and use include guards instead.

[grumpy]

I never employ "#pragma once", and only ever employ include guards.

Pragmas are specific to particular compilers; include guards are guaranteed by the standard to work with all compilers (or, more accurately, preprocessors).

[iMalc]

Some say you can get the best of both, by er ... using both.
Unknown pragmas are supposed to be ignored by the compiler

[grumpy]

Some say you can get the best of both, by er ... using both.

If two approaches achieve the same purpose, but one is not guaranteed to work when you change compilers, better to use the other.

Unknown pragmas are supposed to be ignored by the compiler

Different compilers are also allowed to do different things, when given the same pragma. The whole intent of pragmas is that they do compiler-specific things.

I have heard - but not confirmed - reports of a compiler that supports a #pragma once statement to ensure the body of while loops are executed at least once (i.e. making it equivalent to do .... while).

[Aisthesis]

Wow! I kind of expected varying opinions on this one, but it sounds pretty much unanymous for #ifndef, etc. over #pragma once.

[CornedBee]

Yes, the #ifdef guard is the standard and accepted way of doing it. #pragma once is an MS invention that they use to ensure that the compiler needn't even open the file again. This can save time.
However, every compiler but Microsoft's has been taught to recognize the #ifdef pattern and apply the same optimization. Thus, #pragma once wouldn't have any benefit besides being one line instead of three.
GCC supports #pragma once, but not very well. A performance test by someone in Boost has shown that sometimes GCC gets slower if files have #pragma once in addition to include guards.

[rossipoo]

GCC also allows the #import directive as a replacement for #include and it has an include guard, but again, it's not standard so you cannot count on it for portability. In fact, VC uses #import for including it's own special files.

[grumpy]

GCC supports #pragma once, but not very well. A performance test by someone in Boost has shown that sometimes GCC gets slower if files have #pragma once in addition to include guards.

I suspect that would be because include guards are managed by the preprocessor, and the working of #pragma once is handled by the compiler proper. Net effect of using both is that the relevant workings get executed twice - particularly as gcc generally implements the preprocessing and compilation as distinct phases (in fact, in separate executables that are invoked by the gcc driver).