creating a containor iterator inside a function template

Question

Code is Compiled using GCC. This work without any error in VC++

template <typename T>
void Function(T& A){

  T::iterator it; //Error : dependent-name 'T::iterator' is parsed as a non-type,
                  //but instatiation yields a type.
}

This article states that the compiler can't figure out wether the iterator in T type is a class or just a static member. So we must use typename keyword to classify the symbol as a type.

My question is, since T is known at compile-time then the compiler already knows that iterator inside T is a class (in my case T is vector<int>). So why there is an error?

Also is this another use of the typename keyword beside using it as defining the template parameter T.

UPDATE:

I read all the answers and other answers from here which really answered all my thoughts. I can sum it up to this :

The correct compiler that handle this right is Gcc. VC++ will let you compile a malformed code. The Error that accure while compiling with Gcc is due to the syntax analysis, since Gcc will try to parse the code of the function template but it will find a syntax error which is T::iterator it; because Gcc by Deafault treats T::iterator as a variable (T::iterator is parsed as non-type) and not as a type, to solve this problem you must tell Gcc explicitly to treat T::iterator as a type, this is done by adding the keyword typename.
Now back to VC++. the answer to why this worked is because of existing bug in VC++, it's whether VC++ delay the decision of whether T::iterator is a variable or a type. or the VC++ supplies the keyword typename wherever it think it's required.

Useful Article
Note: Feel free to edit the UPDATE if you find something incorrect.

Answer 1

The article you refer to provides the explanation:

the compiler must be told that specified symbol is actually a type, and not a static symbol of given class.

Consider an example from this article:

class ContainsAType {
   class iterator { ... }:
   ...
};

class ContainsAValue {
   static int iterator;
};

So in your Function() above, the compiler must know whether T::iterator is a type or a static variable. The typename keyword removes that ambiguity in C++.

Answer 2

This thread contains some good discussions about the use of typename in a similar case.

My question is, since T is known at compile-time then the compiler already knows that iterator inside T is a class (in my case T is vector).

Yes, this is why VC++ can do without the typename keyword.

So why there is an error?

Because the standard says that template name look-ups should be done in two phases. This requires disambiguation in some cases (see this). So the error comes about in GCC because it is compliant to the standard in repsect to two-phase name lookups. VC++ on the other hand uses a late-parsing scheme.

As DeadMG pointed out, VC++'s method can fail with more complex code when the compiler can't diagnose the missing typename.

Check out this thread as well.

Answer 3

When the compiler sees T::iterator it;, it doesn't know what T is yet. It will only know what T is when you call the function (instantiation time). This is part of two-phase name lookup, in the first phase, the compiler checks the declaration of Function for syntax errors and looks up all non-dependent names. This helps detect errors at the point of definition rather than waiting until the point of instantiation.

For example:

template <typename T>
struct A
{
    X x;
};

struct X{};

int main()
{
    A<int> a;
}

A good compiler will lookup X and tell you that it doesn't know what it is. However, the MSVC compiler will accept this malformed code.

Here is another example:

template <typename T>
class A : public I_do_not_exist
{
};

A good compiler will tell you I_do_not_exist doesn't exist (MSVC compiles this code).