compiler not inferring template type as expected

I'm using G++ 4.2.1 on linux 2.6.x, and I am trying to get the compiler to automatically know what type I want a template to use based on the lvalue of an assignment like the following:

Code:

template<class T>
T myfunc(double d)
{
  return (T)d;
}

int i;
i = myfunc(1.0);

is this legal c++ code? or do I have to explicitly say:

Code:

i = myfunc<int>(1.0);

The compiler can impossibly deduce what type your function is going to return, so you must specify it explicitly, like you have done in your example.

that's sort of counter-intuitive to me, since the compiler knows exactly what type 'i' is, and I would think that it should be able to figure that out.

Ah yes, well no.
What if it returns some class that can implicitly convert to int?
C++ is not easy language to parse.

Originally Posted by Elkvis

that's sort of counter-intuitive to me, since the compiler knows exactly what type 'i' is, and I would think that it should be able to figure that out.

Why should the compiler assume that there is no conversion in the assignment? At any rate the return type of a function is not a part of its signature.

do you know if C++0x will add return type to the signature of a function?

if I could overload functions with only the return types being different, this would not be an issue, but because C++ doesn't allow it, I have to resort to all this template trickery.

Not my knowledge, no.
I believe you have flawed design.

you have to admit that there would be plenty of things which would be easier if it were possible to do what I suggest.

Perhaps. Perhaps not.
The best you can do is outline your design and help others punch a hole in it and suggest corrections.

I don't think the design is necessarily flawed, just that you have to be explicit about the return type. What if the return type was not assigned to a variable, but used differently:

Code:

std::cout << myfync(1.0); //what would T be

There already is one instance where the C++ compiler determines something by the target type: taking the address of an overloaded function:

Code:

void f(int);
void f(double);

int main()
{
  void (*fp1)(int) = &f; // Takes the address of void f(int)
  void (*fp2)(double) = &f; // Takes the address of void f(double)
  void (*fp3)(void*) = &f; // Error: no appropriate overload
  std::cout << &f; // Error: cannot deduce overload
}

However, to extend this to templates would require making the return type part of the function signature. This, in turn, would break ABI (name mangling rules would have to change), something the new standard really tries to avoid.

Edit: Hmm, wait, it wouldn't require the signature change. Ah, well, I guess I have no idea why they didn't do this. It would allow for some sweet code, but its absence is not crippling.

I'll go into a bit of detail about what I am trying to do.

I have a class that accepts a string (similar in format to an HTTP post string), and splits it up into its key/value pairs. The accessor function for these pairs is declared as follows:

Code:

std::string GetKeyValue(const std::string& str):

sometimes I want to get a key as an integer because it contains a numeric value, so it would be nice to have an overload of the function that returns int, but takes the same parameters.

my solution was the following:

Code:

template <class T> T _GetKeyValue(const std::string& str)
{
  T t;
  GKV(str, t);
  return t;
}

void GKV(const string& str, std::string& t);
void GKV(const string& str, int& t);
void GKV(const string& str, double& t);
void GKV(const string& str, long& t);

I could then just add another overload for any new type I want to return, but as you can tell from this thread, this didn't work as expected.

True. That's why, for example, you have to specify the return type in boost::lexical_cast:

Code:

template <typename Out, typename In>
Out lexical_cast(const In& in)
{
...
}

int i = lexical_cast<int>("224");

Of course, the authors don't mind, because other casts look like this, too.

You can, if you want, write a user level function in terms of a return template proxy in order to facilitate overloading the behavior of a function based solely on the target return type.

I pulled this out of my headers and patched things up to remove other dependencies. This simple mechanic should handle about 90% of uses without problems. (The most obvious case of conversion problems relating to using an instance of the proxy class with the C++ operators, as is normally a concern for conversion operators, should never arise with a conformant compiler simply because the relevant operator is a template, but it is actually possible to trick the compiler, but it should not come up naturally.) With the right utilities you can handle the rest and provide better errors. (As it stands, the errors a good compiler will produce will make you cry.)

Soma

Code:

#include <iostream>
#include <sstream>
#include <string>

template
<
   typename function_F
>
struct return_mastery
{
   return_mastery
   (
      const std::string & data_f
   ):
     data_m(data_f)
   {
   }
   template
   <
      typename type_F
   >
   inline operator type_F ()
   {
      typedef typename function_F::template apply<type_F>::type function_type;
      function_type converter;
      return(converter(data_m));
   }
   std::string data_m;
};

template
<
   typename type_F
>
struct sample_function
{
   template
   <
      typename type_FR
   >
   struct apply
   {
      typedef sample_function<type_FR> type;
   };
   inline type_F operator ()
   (
      const std::string & data_f
   )
   {
      type_F return_value;
      std::istringstream in(data_f);
      std::cout << typeid(type_F).name() << ": ";
      in >> return_value;
      return(return_value);
   }
   typedef sample_function<type_F> type;
};

template <> struct sample_function<double>
{
   template
   <
      typename type_FR
   >
   struct apply
   {
      typedef sample_function<type_FR> type;
   };
   inline double operator ()
   (
      const std::string & data_f
   )
   {
      double return_value;
      std::istringstream in(data_f);
      std::cout << "This is for a double: ";
      in >> return_value;
      return(return_value);
   }
   typedef sample_function<double> type;
};

inline return_mastery<sample_function<void>::type> tester
(
   const std::string & data_f
)
{
   return(return_mastery<sample_function<void>::type>(data_f));
}

int main()
{
   char c(tester("!")); std::cout << c << '\n';
   signed char sc(tester("@")); std::cout << sc << '\n';
   unsigned char uc(tester("$")); std::cout << uc << '\n';
   short s(tester("18")); std::cout << s << '\n';
   signed short ss(tester("-400")); std::cout << ss << '\n';
   unsigned short us(tester("63000")); std::cout << us << '\n';
   int i(tester("78411")); std::cout << i << '\n';
   signed int si(tester("-1145989")); std::cout << si << '\n';
   unsigned int ui(tester("2482918294")); std::cout << ui << '\n';
   long l(tester("95438")); std::cout << l << '\n';
   signed long sl(tester("-72984529")); std::cout << sl << '\n';
   unsigned long ul(tester("31821938")); std::cout << ul << '\n';
   float f(tester("14.178")); std::cout << f << '\n';
   double d(tester("2091.0817")); std::cout << d << '\n';
   return(0);
}