Re: Problem with 'template' as a qualifier

[Rodolfo Lima <rodolfo at rodsoft dot org>]

John Fine escreveu:
> When f() is defined, the compiler must be informed that B is a template 
> or it wouldn't know how to parse the following < character.

That's fine, we must live with it... although the most common case (i.e. 
B<int>, and not 'B < int') isn't what the compiler considers by default, 
even if 'B < int' is ill-defined. That must be something about syntax 
parsing time vs. semantic analysis time.

> Does typename in your example qualify type (not B)?  Is the :: after 
> B<int> the thing that tells the compiler B<int> can't be a function?

It seems that the '::' tells the compiler that what precedes it is a 
type (when the token is followed by another ::), so the 'typename' 
qualifier is only to disambiguate the last token.

My rant about 'typename' is that we have to tell the compiler that we're 
dealing with types even if it makes no sense for it to be a value. That 
is, the following code should be valid:

template <class T> T::other_type function(T::type x)
{
    T::type temp = x;
    return static_cast<T::other_type>(temp);
}

But the standard requires that all T::* should be prefixed by 
'typename'. It makes an exception, tough. Is when we specify a base 
class list, which have to be a type. But why not in other cases?

> Anyway, my suggestion is to be a little nicer to whatever programmer 
> will work on this code after you.  Make more use of typedef to clarify 
> the construction.

I usually do that, but I wanted to prove a (wrong) point in my example, 
the example was contrived on purpose.

Regards,
rod