Inferring the return type of a function or functor in C++

Question

I need to use a function's/functor's returned value without knowing what type it is (that is, as a template).

While I could pass it over to a second function without a problem:

template <typename T>
void DoSomething(T value);

...

DoSomething(FunctionWhoseReturnedTypeIsUnknown(...));

I want to use the returned value inline (without the need to call a second function):

WhatGoesHere? x=FunctionWhoseReturnedTypeIsUnknown(...);

The two methods seem conceptually identical to me (generic-programming-wize), but can the latter be achived in C++?

Answer 1

C++0x introduces the concept of an inferred variable type by using the keyword auto.

auto x = SomeFunction();

The result is the same as C#'s var keyword: a strongly typed variable whose type is the return type of the expression.

In the absence of C++0x there is no good way to achieve this outside of a template. If there ways, C++0x would have no need for this feature.

Answer 2

Not yet. In C++0X you'll be able to use auto as WhatGoesHere. There is already experimental support for this in some compilers (gcc 4.4 for instance).

Answer 3

It depends on your specific use case but sometimes boost::any can be used:

#include <iostream>
#include <boost/any.hpp>

namespace {
  template <class T>
  T return_arg(T t) {
    return t;
  }
}

int main() {
  try {  
    boost::any i = return_arg(1);
    boost::any s = return_arg("a string");
    std::cout << boost::any_cast<int>(i) << " "
          << boost::any_cast<const char*>(s)
          << std::endl;
  }
  catch(const boost::bad_any_cast &) {
      return 1;
  }
}

Answer 4

Until the auto keyword makes it really trivial, one can rely on the convention that function objects provide certain typedef's, including result_type. One just needs to wrap a plain function into a function object. The standard "functional" header provides some (pointer_to_unary_function/pointer_to_binary_function in addition to a couple of member function wrappers). When these are not enough, boost library provides more powerful wrappers.

#include <iostream>
#include <boost/function.hpp>
#include <boost/bind.hpp>

int answer()
{
    return 42;
}

template <class T>
T unknown()
{
    return T();
}

template <class Function>
void foobar(Function unknown)
{
    typename Function::result_type x = unknown();
    std::cout << x << '\n';
}

int main()
{
    foobar(boost::function<int()>(answer));
    foobar(boost::bind(unknown<int>));
}

And below's an example, how you might add a pointer_to_zeronary_function. (I suppose the helper function that helps you create one, ptr_fun, might be added to the standard namespace as well as an overload(?)

template <class T>
class pointer_to_zeronary_function
{
    typedef T(*zeronary_func)();
    zeronary_func func;
public:
    typedef T result_type;
    pointer_to_zeronary_function(zeronary_func f): func(f) {}
    T operator()() const
    {
        return func();
    }
};

template <class T>
pointer_to_zeronary_function<T> ptr_fun(T(*f)())
{
    return pointer_to_zeronary_function<T>(f);
}

...
//usage:
foobar(ptr_fun(answer));