On Fri, 08 Jul 2011 11:08:14 -0400, James Fisher <jameshfis...@gmail.com>
wrote:
On Fri, Jul 8, 2011 at 4:06 PM, James Fisher <jameshfis...@gmail.com>
wrote:
So ... stuff works, but I'm not really sure why one uses function
templating and the other uses return type inference. Any answers?
... Wait, brain malfunction; I think I do understand. The type is
inferable
purely from the function definition in the latter case.
Yes, the return type is determined by the return statement in the function
itself. Note that it would be an error to have two different return types
that compiled into the same function. A frequent use of auto is when the
return type could be different based on template parameters to the
function, or version statements. In these cases, effectively there is
only one return type, because only one return statement gets compiled.
The reason your getSquares(T)() *call* doesn't work is because the
compiler first must instantiate the template, and it doesn't have enough
information to do so. Remember that a function template like this:
T getSquares(T)() {...}
is equivalent to this:
template getSquares(T)
{
T getSquares() {...}
}
So in fact, the compiler cannot evaluate the inner part of the template
until it knows what T is. However, there is a special feature called
implicit function template instantiation (IFTI) which allows the compiler
to infer the values of T from the function call being made. This means
the types of arguments to the function can be used to infer the template
parameters. This *only* works for template functions or templates that
can be reduced to template functions.
So for example:
T foo(T)(T t) {return t;}
you can call this function via:
foo(1);
And T will implicitly be assigned int.
But since your getSquares function takes no parameters, IFTI cannot be
used. Note that the return type does NOT play a role in IFTI.
However, you can still use getSquares, just specify the template parameter
explicitly:
auto sq = getSquares!int();
Another option is to give a default value for T:
T getSquares(T = int)() {...}
-Steve