Thread: Odd template compile error

Here's a stripped-down example of the problem:

Code:

template < typename Type >
struct foo
{
    template < typename Other >
    Other bar( void ) const
    {    
        return Other( );
    }
};

template < typename Type >
void baz( foo< Type > const& object )
{
    object.bar< int >( );
}

int main( void )
{
    baz( foo< double >( ) );    
}

The compiler complains: "expected primary-expression before 'int'" and "expected ';' before 'int'".

Incidentally, with a typedef the problem goes away:

Code:

template < typename Type >
struct foo
{
    template < typename Other >
    Other bar( void ) const
    {    
        return Other( );
    }
};

typedef foo< double >
    foo_double;

void baz( foo_double const& object )
{
    object.bar< int >( );
}

int main( void )
{
    baz( foo_double( ) );    
}

Unfortunately, I can't use the typedef approach here - I just thought I'd point it out.

Any ideas?

EDIT:

I'm using gcc 4.4.0 mingw.

My instincts tell me that you need to disambiguate a template:

Code:

template < typename Type >
void baz( foo< Type > const& object )
{
    object.template bar< int >( );
}

Originally Posted by Sebastiani

Your instincts were correct!

Yeah, I checked it myself just before posting in case they were wrong, heheh.

Originally Posted by Sebastiani

I still don't understand why the disambiguation is necessary, though. Do you know of any good links on the issue?

I read of this in Stephen Dewhurst's book C++ Common Knowledge.

Originally Posted by Sebastiani

You really are a C++ witch!

But yeah, it seems more like witchcraft than common knowledge

Code:

template < typename Type >
void baz( foo< Type > const& object )
{
    object.bar< int >( );
}

I may be mistaken, but the compiler basically shouldn't know about template methods within another template class, so it has to interpret < as less-than. (When first pass is done to check non-dependent stuff, which has to be correct by the standard regardless of any instantiations.)

It should be similar to using typename in front of type names nested in template classes: the compiler has to assume it is a non-type identifier otherwise.

Again, technically it is possible that there is a specialization of foo where bar is not a templated member function. (The point being, probably, not to allow situations where the same code would indeed result in different meaning, given different specializations.)