Re: Is it me or is it gcc?
On Sep 12, 7:25 pm, Andrey Tarasevich <andreytarasev...@hotmail.com>
wrote:
Boltar wrote:
On Sep 12, 3:25 pm, blargg....@gishpuppy.com (blargg) wrote:
How so? In both cases below the compiler doesn't know
anything about the type derived from, since Foo could have
specializations:
template<typename T> class U : public T;
template<typename T> class Foo { ... };
template<typename T> class U : public Foo<T>;
It doesn't in my example. For heavens sake , is it too much
to ask a compiler to know when specialisation is in use and
when it isn't in the same module for the same class?
It is not a matter of whether it is "too much to ask " or not.
It is a matter of common sense. Having the semantics of
_unqualified_ names to be implicitly dependent on the template
context would deal a huge amount of damage to the readability
of the code. It would be downright dangerous.
Don't exagerate. Template implementations existed for a long
time without dependent look-up, and there weren't any real
problems in practice. (Of course, existing "best practice" even
then said to always fully qualify such names anyway, using
::whatever or this->whatever to ensure that regardless of the
instantiation context, you got the symbol you wanted.)
For these reasons C++ is pretty consistent in this regard: the
user has to explicitly acknowledge the "dependentness" of a
name in cases like that.
IMHO, that's where there is a real problem. The user doesn't
explicitly state what is dependent or not; the compiler
"guesses" according to a fixed set of heuristics, and the user
has to then trick the compiler into guessing what he wants it to
guess. IMHO, 1) dependent names are a solution to something
that isn't a real problem in practice, and 2) if the distinction
is deemed desirable (because it does offer some protection),
then the user should state clearly which names are dependent,
and not have to second guess the heuristics the compiler uses
for guessing.
I'd rather a compiler which followed well-defined rules
rather than vague things like "obvious", which differ from
one person to the next. For one, the compiler sees a lot
more than the human does, in terms of all the details.
Rubbish. These rules make it virtually impossible to use
inheritence with templates. Which rather defeats the point
of using C++.
No, quite the opposite. These rules are what keeps inheritance
useful with templates.
Come now, inheritance was useful long before the rules were
adopted.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34