I'm working on a codebase that is known to only run on windows and be compiled under Visual Studio (it integrates tightly with excel so it's not going anywhere). I'm wondering if I should go with the traditional include guards or use
#pragma once for our code. I would think letting the compiler deal with
#pragma once will yield faster compiles and is less error prone when copying and pasting. It is also slightly less ugly
Note: to get the faster compile times we could use Redundant Include Guards but that adds a tight coupling between the included file and the including file. Usually it's ok because the guard should be based on the file name and would only change if you needed to change in the include name anyways.
I don't think it will make a significant difference in compile time but
#pragma once is very well supported across compilers but not actually part of the standard. The preprocessor may be a little faster with it as it is more simple to understand your exact intent.
#pragma once is less prone to making mistakes and it is less code to type.
To speed up compile time more just forward declare instead of including in .h files when you can.
I prefer to use
I just wanted to add to this discussion that I am just compiling on VS and GCC, and used to use include guards. I have now switched to
#pragma once, and the only reason for me is not performance or portability or standard as I don't really care what is standard as long as VS and GCC support it, and that is that:
#pragma once reduces possibilities for bugs.
It is all too easy to copy and paste a header file to another header file, modify it to suit ones needs, and forget to change the name of the include guard. Once both are included, it takes you a while to track down the error, as the error messages aren't necessarily clear.