I totally agree with Trienco except on one point: the extra inclusion guards not being worth it... That is incorrect in any large codebase unfortunately. The insertion style of the preprocessor costs a lot actually. Every included file must be both lexxed and parsed even if it is completely ignored. The reason being that I can have a header where each file which includes it changes preprocessor defines and as such the results of inclusion change from parse to parse. An include guard around the header unique define removes the overhead since "you" know, but the compiler does not, that nothing in the header parse will change. Most compilers now include a "pragma once" specifically for this reason, the compiler will assume nothing in the parse can change and as such if included once, it will not lexx/parse the file again if it see's the include.
A recent thread is a perfect example, in production code I had to do the following:
.. my code..
With well documented headers, potentially lots of different preprocessor defines, such unprotected headers are a bane to multicore compilations. The file cache is usually smaller than your source code, as such, multiple cores end up fighting over disk access for no good reason except to repeatedly parse unchanging files.