«

With the following code, I get the following error from my compiler:
"In member function 'void B<U>::C()': error: expected ';' before 'x'".
Which subtlety of using templates am I not aware of?

#include <vector>
template <class T> struct A {};
template <class U> struct B {
void C() { std::vector<A<U> >::const_iterator x;}
};
int main(){}

m0shbear wrote:
> With the following code, I get the following error from my compiler:
> "In member function 'void B<U>::C()': error: expected ';' before
> 'x'". Which subtlety of using templates am I not aware of?
>
> #include <vector>
> template <class T> struct A {};
> template <class U> struct B {
> void C() { std::vector<A<U> >::const_iterator x;}
> };
> int main(){}

That the compiler cannot formally know that
std::vector<A<U>>::const_iterator is a type (because someone could
specialize std::vector for some user defined types). You have to add a
'typename' to specify what it is:

void C() { typename std::vector<A<U> >::const_iterator x;}


Bo Persson

On Feb 6, 3:54*am, "Bo Persson" <b...@gmb.dk> wrote:
> m0shbear wrote:
> > With the following code, I get the following error from my compiler:
> > "In member function 'void B<U>::C()': error: expected ';' before
> > 'x'". Which subtlety of using templates am I not aware of?
>
> > #include <vector>
> > template <class T> struct A {};
> > template <class U> struct B {
> > void C() { std::vector<A<U> >::const_iterator x;}
> > };
> > int main(){}
>
> That the compiler cannot formally know that
> std::vector<A<U>>::const_iterator is a type (because someone could
> specialize std::vector for some user defined types). You have to add a
> 'typename' to specify what it is:
>
> *void C() { typename std::vector<A<U> >::const_iterator x;}
>
> Bo Persson

Ah, now I understand the point of typename for disambiguating types. I
need to start reading TC++PL more religiously. In its listing of
vector, it had "typedef _typename_ ..." for a reason. And now I
understand what it is.

I'm curious as to why it's not in the C++ FAQ yet.

Bo Persson <> wrote:
> That the compiler cannot formally know that
> std::vector<A<U>>::const_iterator is a type (because someone could
> specialize std::vector for some user defined types). You have to add a
> 'typename' to specify what it is:

Is there any conrete example where the same dependent name could be
used as both a type name and a non-type name, and this could potentially
cause confusion? Why exactly is the 'typename' keyword necessary?

m0shbear wrote:

> With the following code, I get the following error from my compiler:
> "In member function 'void B<U>::C()': error: expected ';' before 'x'".
> Which subtlety of using templates am I not aware of?
>
> #include <vector>
> template <class T> struct A {};
> template <class U> struct B {
> void C() { std::vector<A<U> >::const_iterator x;}
> };
> int main(){}

For the typename FAQ see http://stackoverflow.com/questions/610245/where-to-
put-the-template-and-typename-on-dependent-names

Juha Nieminen wrote:
> Bo Persson <> wrote:
>> That the compiler cannot formally know that
>> std::vector<A<U>>::const_iterator is a type (because someone could
>> specialize std::vector for some user defined types). You have to
>> add a 'typename' to specify what it is:
>
> Is there any conrete example where the same dependent name could be
> used as both a type name and a non-type name, and this could
> potentially cause confusion? Why exactly is the 'typename' keyword
> necessary?

Yes, if you specialize a class there is no requirements that the base
template and the specialization should have anything in common (except
their names .


template<class T>
class vec
{
public:
class const_iterator
{
public:
// some members here
};
};

template<>
class vec<int>
{
public:
double const_iterator; // silly, but possible
};


Now, what is vec<T>::const_iterator, a type or a member variable?
Depends on what T is!


Bo Persson

On Feb 7, 5:12 pm, Juha Nieminen <nos...@thanks.invalid> wrote:
> Bo Persson <b...@gmb.dk> wrote:
> > That the compiler cannot formally know that
> > std::vector<A<U>>::const_iterator is a type (because someone could
> > specialize std::vector for some user defined types). You have to add a
> > 'typename' to specify what it is:

> Is there any conrete example where the same dependent name could be
> used as both a type name and a non-type name, and this could potentially
> cause confusion? Why exactly is the 'typename' keyword necessary?

extern int p;
template<typename T>
struct S : B<T>
{
B<T>: * p; // marked statement
};

If B<T>: is the name of a type, the marked statement is a
declaration of a pointer to that type. If it is the name of a
constant or a variable, the marked statement is an expression
statement, and the * is multiplication.

In a lot of cases, context would allow the compiler to make it
clear: only a type is legal, or a type is not legal, but the
committee decided to not require the compiler to take any
context into consideration.

--
James Kanze

Bo Persson <> wrote:
> Juha Nieminen wrote:
>> Bo Persson <> wrote:
>>> That the compiler cannot formally know that
>>> std::vector<A<U>>::const_iterator is a type (because someone could
>>> specialize std::vector for some user defined types). You have to
>>> add a 'typename' to specify what it is:
>>
>> Is there any conrete example where the same dependent name could be
>> used as both a type name and a non-type name, and this could
>> potentially cause confusion? Why exactly is the 'typename' keyword
>> necessary?
>
> Yes, if you specialize a class there is no requirements that the base
> template and the specialization should have anything in common (except
> their names .

In your example if you try to use the specialization in code where
'const_iterator' is expected to be a type, you get a syntax error. In
the exact same way as if that 'typename' keyword had been specified.
So what's the difference?

That's not what I asked. I asked if there's a situation where you *don't*
get a syntax error, but it compiles fine but causes unwanted behavior.

James Kanze <> wrote:
> In a lot of cases, context would allow the compiler to make it
> clear: only a type is legal, or a type is not legal, but the
> committee decided to not require the compiler to take any
> context into consideration.

The following doesn't compile. Why shouldn't it? I see no rational
reason why the compiler should refuse to compile it.

//---------------------------------------------------------------
#include <iostream>

template<typename T>
void foo()
{
T::f(); // Is 'f' a function or a type?
}

struct A
{
// 'f' is a function
static void f() { std::cout << "A\n"; }
};

struct B
{
// 'f' is a type
struct f
{
f() { std::cout << "B\n"; }
};
};

int main()
{
foo<A>();
foo<B>(); // Fails because B::f is a type
}
//---------------------------------------------------------------

"Juha Nieminen" <> wrote in message
news:4d50e156$0$2819$...
> James Kanze <> wrote:
>> In a lot of cases, context would allow the compiler to make it
>> clear: only a type is legal, or a type is not legal, but the
>> committee decided to not require the compiler to take any
>> context into consideration.
>
> The following doesn't compile. Why shouldn't it? I see no rational
> reason why the compiler should refuse to compile it.
>
> //---------------------------------------------------------------
> #include <iostream>
>
> template<typename T>
> void foo()
> {
> T::f(); // Is 'f' a function or a type?
> }
>
> struct A
> {
> // 'f' is a function
> static void f() { std::cout << "A\n"; }
> };
>
> struct B
> {
> // 'f' is a type
> struct f
> {
> f() { std::cout << "B\n"; }

Where is this function declared?

> };
> };
>
> int main()
> {
> foo<A>();
> foo<B>(); // Fails because B::f is a type
> }
> //---------------------------------------------------------------
>