Why do I need the typename keyword?

[Anonymous]

I'm trying to port code from VC.net to VC.net 2003. Here's a typical
piece of code that's often used:


template<class T> class PseudoContainer {
typedef T::iterator iterator; // this line will change in the next
example...
};


This compiles just fine under VC.net but it will not compile under VC.net
2003. In order to get this to compile with the new compiler, I need to add
the typename keyword, like so:


template<class T> class PseudoContainer {
typedef typename T::iterator iterator; // this line was changed from
the previous example...
};


Now, I can actually understand why you need the typename keyword. It's
because the compiler can't tell if T::iterator is a type or a static member
of T. Thus, you must tell it with the typename keyword. However, if that's
the case, then why did it compile just fine under VC.net?

Any insight into this will be greatly appreciated!

 

[Ioannis Vranos]

I'm trying to port code from VC.net to VC.net 2003. Here's a typical
piece of code that's often used:


template<class T> class PseudoContainer {
typedef T::iterator iterator; // this line will change in the next
example...
};


This compiles just fine under VC.net but it will not compile under VC.net
2003. In order to get this to compile with the new compiler, I need to add
the typename keyword, like so:


template<class T> class PseudoContainer {
typedef typename T::iterator iterator; // this line was changed from
the previous example...
};


Now, I can actually understand why you need the typename keyword. It's
because the compiler can't tell if T::iterator is a type or a static member
of T. Thus, you must tell it with the typename keyword. However, if that's
the case, then why did it compile just fine under VC.net?

Any insight into this will be greatly appreciated!

typename is used when writing templates and accessing other template member
*types*. Since you access the type inside of a template and not of an
instance, it would be hard work for the compiler to distinguish such things,
so you tell the compiler explicitly that it is a type defined inside a
template and not in a class or function (or template instance which is also
a class or function).

(E.g. vector<int> is a class, vector is a template).






Ioannis Vranos

 

[John Carson]

I'm trying to port code from VC.net to VC.net 2003. Here's a
typical piece of code that's often used:


template<class T> class PseudoContainer {
typedef T::iterator iterator; // this line will change in the
next example...
};


This compiles just fine under VC.net but it will not compile under
VC.net 2003. In order to get this to compile with the new compiler, I
need to add the typename keyword, like so:


template<class T> class PseudoContainer {
typedef typename T::iterator iterator; // this line was changed
from the previous example...
};


Now, I can actually understand why you need the typename keyword.
It's because the compiler can't tell if T::iterator is a type or a
static member of T. Thus, you must tell it with the typename keyword.
However, if that's the case, then why did it compile just fine under
VC.net?

Any insight into this will be greatly appreciated!

VC++ 7.1 is more standard conforming than VC++ 7.0, which means that some
things 7.0 allowed are no longer allowed in 7.1. Some of these changes may
have been just for the sake of being conformant to the standard; others may
be because 7.0 allowed you to do things that caused ambiguities (perhaps
only in special cases) that the compiler writers had not fully appreciated
at the time 7.0 was written.