template function argument deduce

Hello everyone,

Why in the following code segment (along with Bjarne's comments), function
get_new can not deduce template parameter type to be int by its return value
assignment to int * p1, and deduce T* is int*, and so T is int (e.g. as we
did for function release in the same sample below)?

[Code]
class Memory { // some Allocator
public:
template <class T> T * get _new ();
template <class T > void release (T&);
/ / ...
};

template <class Allocator> void f (Allocator &m )
{
int * p1 = m.get _ new <int>(); // syntax error: int after lessthan
operator
int * p2 = m.template get _ new <int>(); // explicit qualification
/ / ...
m.release (p1); // template argument deduced: no explicit qualification needed
m.release (p2 );
}
[/Code]

Explicit qualification of get _new() is necessary because its template
parameter cannot be deduced. In this case, the t e m p l a t e prefix must be
used to inform the compiler (and the human reader) that get _new is a member
template so that explicit qualification with the desired type of element is
possible. Without the qualification with template , we would get a syntax
error because the < would be assumed to be a less than operator. The need for
qualification with template is rare because most template parameters are
deduced.

thanks in advance,
George