Re: Header File Clutter
On Jan 14, 11:13 pm, Keith H Duggar <dug...@alum.mit.edu> wrote:
On Jan 14, 3:59 pm, Dilip <rdil...@lycos.com> wrote:
On Jan 14, 2:59 pm, Keith H Duggar <dug...@alum.mit.edu> wrote:
On Jan 14, 2:00 pm, James Kanze <james.ka...@gmail.com> wrote:
My "fantasy" compiler is called g++. The source code is
available, so you can even see how it does it.
It doesn't do it. It's up to you to point out the g++ code
that you claim does (or GNU documentation making the claim)
to prove your claim. However, giving that you just wrote
Maybe I am missing something blindingly obvious but gcc docs
does say this:
"GNU CPP optimizes even further. It remembers when a header
file has a wrapper `#ifndef'. If a subsequent `#include'
specifies that header, and the macro in the `#ifndef' is
still defined, it does not bother to rescan the file at
all."
Thanks for the reference. (My knowledge about this comes from
private discussions with g++ developers. I was unaware of what
the documentation said.)
What you are missing is that there is a set of restrictions on
the header file and include guards that must be satisfied in
order for such a optimization to be standard conformant. In
other words, the optimization is not general.
You don't want it to be general. The classical example is
<assert.h>; this must be textually reread each time it is
included. (I suppose that it would be possible for a compiler
to avoid this, and only reread it if NDEBUG has changed since
the last time it was read, but I don't know of any compiler
which does this.)
For example, g++ cannot perform the optimization if there are
any directives outside of the guard. In fact It can't do it
if there any tokens whatsoever outside the guard. And it can
only optimize for the simplest possible guard for example no
#else, no #elif, no logical operations, etc.
Obviously. And why is this a problem? Putting all tokens
inside the guard is the equivalent of using #pragma once.
For example, Kevin's suggestion else thread to put #pragma
once as the very /first/ line of headers would break the
optimization
Maybe. I don't know how g++ does this, but it wouldn't be to
difficult to implement it so that unrecognized pragmas don't
count as tokens.
and if the platform didn't support #pragma once then you are
worse off than without it. (As an aside that is one example of
the subtle problems that #pragma once can cause).
That is, potentially, a good reason *not* to use it. Another
might be that #pragma once has some different meaning. One that
you don't want. That's a general problem with pragmas, and a
valid reason for avoiding them. (In practice, I'd use this one,
and take the risk, until it did actually cause a problem.)
In other words, g++ does not in general avoid opening headers more
than once. It only avoids it in a very specific case albeit a common
case. And there is /no/ general solution for C++ from what I've read
and seen.
Of course you can't systematically not open a header. In cases
like <assert.h>, it must be reread. Intentionally. The only
discussion is how you specify that a header need not be reread:
an implementation pragma, or just by putting all significant
tokens in include guards.
--
James Kanze