In list<tNode<T>*>::iterator, you have a dependant name, that is, a name that depends on a template parameter. As such, the compiler can’t inspect list<tNode<T>*> (it doesn’t have its definition at this point) and so it doesn’t know whether list<tNode<T>*>::iterator is either a static field or a type. In such a situation, the compiler assumes that … Read more
A name in C++ can pertain to three different tiers of entities: Types, values, and templates. struct Foo { typedef int A; // type static double B; // value template <typename T> struct C; // template }; The three names Foo::A, Foo::B and Foo::C are examples of all three different tiers. In the above example, … Read more
The typename is required by the standard. Template compilation requires a two step verification. During the first pass the compiler must verify the template syntax without actually supplying the type substitutions. In this step, std::map::iterator is assumed to be a value. If it does denote a type, the typename keyword is required. Why is this … Read more
The solution is typeid(T).name() which returns std::type_info.
Short answer: Whenever referring to a nested name that is a dependent name, i.e. nested inside a template instance with unknown parameter. Long answer: There are three tiers of entities in C++: values, types, and templates. All of those can have names, and the name alone doesn’t tell you which tier of entity it is. … Read more
(See here also for my C++11 answer) In order to parse a C++ program, the compiler needs to know whether certain names are types or not. The following example demonstrates that: t * f; How should this be parsed? For many languages a compiler doesn’t need to know the meaning of a name in order … Read more