Why can't C++ deduce template type from assignment?

Question

int x = fromString("test") :could not deduce template argument for 'ValueType'

int x = fromString<int>("test") : works fine as expected

So why does the compiler struggle here? I see it with all kinds of real template functions, not just this silly example. It must be a feature of the language, but what?

Answer 1

You can't deduce based on the return type. You can, however, implement a workaround with similar syntax, using the overloaded cast operator:

#include <iostream>
#include <sstream>
#include <string>
using namespace std;

class FromString{
private:
    string m_data;
public:
    FromString(const char*data) : m_data(data) {} 

    template<typename T>
    operator T(){
        T t;
        stringstream ss(m_data);
        ss >> t;
        return t;
    }

};

template<> FromString::operator bool(){
    return (m_data!="false"); //stupid example
}

int main(){

    int ans = FromString("42");    
    bool t = FromString("true");
    bool f = FromString("false");

    cout << ans << " " << t << " " << f << endl;

    return 0;
}

Output:

42 1 0

Answer 2

C++ doesn't do type inference on the return value. I.e., the fact that it is being assigned to an int isn't used in template parameter deduction.

(Removed edit, since someone else presented the overloaded cast solution already.)

Answer 3

It looks like your template has the return type templated which cannot be automatically deduced which is why you need to add it in here.

Answer 4

Besides the bad choice for an example (probably makes sense to have int x = to<int>("1235") rather than toString), the problem is that the return type does not participate in overload resolution or type inference^[1]. The reason for this is that the expression can be used in many places where the type of the return cannot be deduced:

// assuming template <typename T> T to( std::string ):
//
f( to("123") );          // where there are two overloads f(int), f(double)
int x = 1.5 * to("123"); // T == int? T == double?
to("123");               // now what? returned object can be ignored!

So the decision is that the return type will not take part in overload resolution or type deduction.

^[1] There is a single exception to this rule, which is the evaluation of a function pointer with more than one overload, where the overload must be selected by either the destination pointer or an explicit cast, but this is just the one exception and is not used in any other context:

void f();
void f(int);
void g( void (*)() );
void g( void (*)(int) );

void (*p1)() = &f;      // overload selected based on destination type
void (*p2)(int) = &f;
g( (void (*)(int))&f ); // overload selected based on explicit cast

Answer 5

The return type of a function is dependent on overload resolution, not the other way around.

There is a trick that works though: operator= usually exists only for equal LHS/RHS argument types, except when an explicit operator= is defined (whether as standalone or as a member does not matter).

Thus, overload resolution will find operator=(int &, int), and see if the return value from your function is convertible to int. If you return a temporary that has an operator int, this is an acceptable resolution (even if the operator int is in the generic form of a template<typename T> operator T).

Thus:

template<typename T, typename U>
U convert_impl(T const &t);

template<typename T>
struct convert_result {
    convert_result(T const &t) : t(t) { }
    template<typename U> operator U(void) const { return convert_impl<U>(t); }
    T const &t;
};

template<typename T>
convert_result<T> convert(T const &t) { return t; }