Usage of typename in typedef versus inheritance

Question

Just wondering about C++ typename, used to tell the parser that some symbols are types. Why must we use it after typedef and not for inheritance?

Example: imagine you have this

struct C { /* a class */ }; 
template<class T> struct S {
   typedef C type; // S<T>::type is a type
};

What's bothering me is this:

template<class T> struct Typedef {
   typedef typename S<T>::type MyType; // needs typename
};
template<class T> struct Inheritance
   :  S<T>::type                       // doesn't need typename
{ };

In both cases the parser should expect a type, so it could parse S<T>::type as one. Why does it only do so for inheritance, and not for typedefs? The pattern seems the same to me:

typedef $type$ $new_symbol$;
class $new_symbol$ : $type$ { $definition$ };

Or is there a usage of typedef I'm not aware of, which make this ambiguous?

PS: I'm pretty sure this has already been asked, but I can't find it (there's a lot of noise related to the typename keyword). This question is only about the syntax, not whether it's better to use inheritance or typedefs. I appologize in advance if there's a duplicate.

It has been answered before. Take a look here: http://stackoverflow.com/questions/610245/where-and-why-do-i-have-to-put-the-template-and-typename-keywords — lapk, Mar 13 '14 at 09:42
@PetrBudnik The link doesn’t actually contain an answer to this specific question. — Konrad Rudolph, Mar 13 '14 at 09:56
@KonradRudolph It certainly does and in great detail. Read the accepted answer's sections **The "typename" keyword** and **Additional notes and examples**. — lapk, Mar 13 '14 at 15:03
@PetrBudnik: I just read both sections, the answer is detailed as you said, but I couldn't find an answer there :\ — Antoine, Mar 13 '14 at 15:08
@Petr You’re mistaken. Read my answer here, and tell me where this information is explained in the accepted answer of the other question. Johannes doesn’t even mention `typedef` (and the one code snippet which uses a `typedef` doesn’t have a dependent name, and consequently doesn’t require a `typename`). — Konrad Rudolph, Mar 13 '14 at 15:13
@KonradRudolph I stand corrected. Indeed, while it is shown that `typename` is needed in case of `typedef` and is not allowed in base-class list, it does not explain the reasons behind it for `typedef` case as explained in your answer. — lapk, Mar 13 '14 at 17:48

score 3 · Accepted Answer · answered Mar 13 '14 at 09:51

The reason is that the typedef syntax is more variable than the inheritance syntax. Normally you would write typedef first, and the type name second. But the order is actually unimportant. To wit, the following is a valid typedef:

int typedef integer_type;

Now consider what happens if we use a dependent name:

S<T>::type typedef integer_type;

Without doing some non-trivial lookahead, the parser cannot know that S<T>::type refers to a type name here (because it hasn’t yet seen the typedef), so by the disambiguation rules it infers a value. For consistency in the grammar, there is no special case for prefixed typedef (which, you are right, is unambiguous). There could be a special case, but there simply isn’t.

Thanks for this short and to the point anser! I didn't know this syntax, this was exactly what I was looking for;) — Antoine, Mar 13 '14 at 10:06

Usage of typename in typedef versus inheritance

1 Answers1