Thread: Header file multiple inclusion question

Originally Posted by cpjust

So in the case where you'd actually want to include multiple times, they could have added a #pragma many statement (the opposite of #pragma once).

I disagree. The bottom line is that the programmer has to understand what will happen when any given input file is fed to the compiler. Introducing #pragma's (which are a standard means of allowing compiler specific extensions) to work around lack of programmer understanding is not a particularly good approach.

The basic issue here is that the preprocessor works by doing text substitution, whereas the C++ (and C) language are token based. The advocates of things like #pragma once tend to incorrectly assume the preprocessing phase honours rules of the language accepted by the compilation phase (hence the fact that such things affect lexical analysis by the compiler).

Originally Posted by cpjust

That way in 99.999% of header files where you don't want it to be included more than once, you don't have to worry about adding include guards (which is a common noob mistake), and only in the rare cases when you do want it multiply included would you need to add an extra line of code.
But we're stuck with the way it works now, so it doesn't make much difference what I think might have been a good feature...

The real solution is either to properly understand the preprocessor (include guards are something quite consistent with how the preprocessor works) or for the language to include some scheme other than the preprocessor for separating declarations from definitions (which happens with a number of languages other than C or C++). Both approaches have their trade-offs, despite each having strong advocates.

Originally Posted by grumpy

I disagree. The bottom line is that the programmer has to understand what will happen when any given input file is fed to the compiler. Introducing #pragma's (which are a standard means of allowing compiler specific extensions) to work around lack of programmer understanding is not a particularly good approach.

The basic issue here is that the preprocessor works by doing text substitution, whereas the C++ (and C) language are token based. The advocates of things like #pragma once tend to incorrectly assume the preprocessing phase honours rules of the language accepted by the compilation phase (hence the fact that such things affect lexical analysis by the compiler).


The real solution is either to properly understand the preprocessor (include guards are something quite consistent with how the preprocessor works) or for the language to include some scheme other than the preprocessor for separating declarations from definitions (which happens with a number of languages other than C or C++). Both approaches have their trade-offs, despite each having strong advocates.

The whole point of compilers is to make programming easier, otherwise we'd all be coding in binary machine code. I've never had a problem with using header guards, but it is more typing, and you need to come up with unique names for the guards...
If the compiler & pre-processor worked the way I described, then understanding how the pre-processor worked would mean understanding that you don't need header guards since it would take care of that automatically and only in the exceptional cases would you need to do something extra.
The goal is to make life easier, not more complicated.