C++ – Should I still use #include guards AND #pragma once

ccompiler-constructioninclude-guardspragma

enter image description here

http://en.wikipedia.org/wiki/Pragma_once
Should I still use include guards when all of these compilers support #pragma once?
A lot of responses on stack overflow say to use both for compatibility, but I'm not sure if that still rings true.
What compilers today don't support #pragma once?

I am not sure if using both was just a recommendation before it became widley adopted, or if there are still very good reasons to use both methods.
Any examples of when only using #pragma once will cause problems?

Best Answer

It depends on how much portable your program is expected to be.

As long as you are writing a program which is supposed to work with compilers which you know definitely support #prama once, just using #pragma once should suffice. But doing so you restrict your program to set of compilers which support the implementation defined feature.

If you need your program to work on all compilers then you should use #pragma once and include guards both.

In case a compiler does not support #pragma once it will simply ignore it[Ref#1], in such a case the header guards will serve you the purpose, so nothing wrong in using them both when you are not aware of features supported by your target compilers.

So if you want your program to be 100% portable on different compilers the ideal way is still to use only the include guards. As @CharlesBailey rightly points out since the behavior for #pragma once is implementation defined, the behavior on an unknown compiler might have a detrimental effect on your program.

[Ref#1]
Standard C++03: 16.6 Pragma directive

A preprocessing directive of the form

# pragma pp-tokensopt new-line

causes the implementation to behave in an implementation-defined manner. Any pragma that is not recognized by the implementation is ignored.

Related Topic