Styjun

Can compiler not deduce the return type of a function if the return type happens to be a template parameter? Or I am making mistake in following code.

#include <iostream>

template <typename TT> 
TT retBoolFail(bool a) 
 return true; 


template <typename TT> 
void retBoolSuccess(bool a, TT& ret) 
 ret = true; 
 return; 


int main() 
 bool ret; 
 retBoolSuccess(true, ret); // Success 
 retBoolFail(true); // Failure 
 return 0; 

line 'RetBoolFail(true)' fails with following error.

-*- mode: compilation; default-directory: "~/work/c++/tupleTemplate/" -*-
Compilation started at Thu Mar 21 16:52:50

g++ -c simpletemp.cc -std=c++1z -g; g++ -o simpletemp simpletemp.o
simpletemp.cc: In function ‘int main()’:
simpletemp.cc:17:21: error: no matching function for call to ‘retBoolFail(bool)’
 retBoolFail(true); // Failure
 ^
simpletemp.cc:4:4: note: candidate: template<class TT> TT retBoolFail(bool)
 TT retBoolFail(bool a) {
 ^
simpletemp.cc:4:4: note: template argument deduction/substitution failed:
simpletemp.cc:17:21: note: couldn't deduce template parameter ‘TT’
 retBoolFail(true); // Failure
 ^
Compilation finished at Thu Mar 21 16:52:50

Thanks.

When the name of a template is used as a function to be called, template argument deduction uses only the function arguments and the template function signature, and not the function body.

One reason this rule would be difficult to change in the Standard is because of how things work if the name is overloaded. The fuller picture there is:

1. Name lookup finds a set of functions and function templates.




2. For each function template in the set, template arguments are determined from explicit template arguments, deduction, and/or default template arguments. If deduction fails, or if substituting the determined template arguments into the function type does something invalid, the function template is just discarded from the overload set as non-viable.




3. For every function signature (whether from a template or not), a check is done to see whether the function parameters and function arguments match up. If not, the function is not viable and is discarded from the overload set.




4. Overload resolution compares the remaining viable functions. For most of the process, function types from templates are treated just like non-template functions, but there are a few final tie-breaker rules specific to function template specializations.




5. If overload resolution selected a function template specialization and the context is one that requires a function definition to exist, then the function body is also instantiated to produce that definition. If substituting the template arguments parameters into the function body does something invalid, the program is ill-formed.

So there's a distinction here between if and when a function template's function type is instantiated, and when the function body is instantiated, and the results of an invalid template parameter usage in the two cases. Deducing from the function body would muddle this up.

But there are some other situations where a template parameter in a function template return type can be involved in template argument deduction. (This list might not be exhaustive.)

If a pointer to function or reference to function is initialized from a function template name (or its address for the pointer case), the return types are involved in template argument deduction:

template <typename TT>
TT f();

unsigned int (&func_ptr)() = f; // TT deduced as unsigned int

int g(double (*)());
int g_of_f = g(f); // TT deduced as double

A class or class template can have a conversion function template. Then some uses of an expression with that class type can implicitly use that template, which requires deducing the template arguments in its return type (which is also the thing following the operator keyword in its declarations).

class A 
public:
 template <typename TT>
 operator std::shared_ptr<TT>() const;
;

std::shared_ptr<int> p = A; // TT deduced as int

Also note that a function or function template using a "placeholder type" as its return type (the return type contains the keyword auto) does deduce its return type from the body's return statements (that are not skipped because of "if constexpr"). Though a function without a template-head is still just one function with one specific type, not a function template, and this deduction is a separate step from any template argument deductions.

auto retBool(bool a) 
 return true; // return type is bool


template <typename T>
constexpr const auto* constify(T* ptr) 
 return ptr; // return type is const T* (T* if T is already const)

No, deduction only occurs within the parameter list. You can use auto instead or just make it a non-template function with a hard-coded return type.

Type deduction doesn't work for return types only for function template arguments.

In your case you have to use

retBoolFail<bool>(true);

You have to hint the compiler to deduce the type of return type. Even using auto in the function template will still necessitate you to hint the compiler at the calling site.