Thread: 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);

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.

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.

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

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.

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