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 );
}

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

Template parameters can only be deduced from function parameters, never from return types. That's just the way it is.

And what's with all the stray spaces?

Thanks CornedBee,

Originally Posted by CornedBee

Template parameters can only be deduced from function parameters, never from return types. That's just the way it is.

And what's with all the stray spaces?

Question answered.


regards,
George