C++0x lambda, how can I pass as a parameter?

Question

Please look at the following C++0x lambda related code:

typedef uint64_t (*WEIGHT_FUNC)(void* param);
typedef std::map<std::string, WEIGHT_FUNC> CallbackTable;

CallbackTable table;
table["rand_weight"] = [](void* param) -> uint64_t
{
  return (rand() % 100 + 1);
};

I got an error (in Visual Studio 2010) that the lambda couldn't be converted to the type of WEIGHT_FUNC. I also know the answer: using std::function object:

typedef std::function<uint64_t (void*)>  WEIGHT_FUNC;

However, I also want to know how I can receive the type of lambda WITHOUT using std::function. What type should it be?

Answer 1

Try with (not tested) :

#include <function>

typedef std::function< int64_t (void*) > weight_func;
typedef std::map<std::string, weight_func > CallbackTable;

I don't think there is any other way to do this than to use std::function or equivalent.

Answer 2

If you really insist on not using function<> then you could probably use decltype:

typedef decltype([](void*)->uint_64{return 0;}) my_lambda_type;

I really don't recommend this though since you're drastically limiting yourself and I don't even know if two lambda's with the same signature are guaranteed to be the same type.

Answer 3

The conversion to function pointer is relatively new: It was introduced with N3043 on February 15, 2010.

While e.g. GCC 4.5 implements it, Visual Studio 10 was released on April 12, 2010 and thus just didn't implement it in time. As James pointed out, this will be fixed in future releases.

For the moment you have to use one of the alternative solutions provided here.

Technically something like the following workaround would work, but without variadic templates its no fun to generalize it (Boost.PP to the rescue...) and there is no safety net against passing capturing lambdas in:

typedef uint64_t (*WeightFunc)(void* param);

template<class Func> WeightFunc make_function_pointer(Func& f) {
    return lambda_wrapper<Func>::get_function_pointer(f);
}

template<class F> class lambda_wrapper {
    static F* func_;
    static uint64_t func(void* p) { return (*func_)(p); }    
    friend WeightFunc make_function_pointer<>(F& f);    
    static WeightFunc get_function_pointer(F& f) {
        if (!func_) func_ = new F(f);
        return func;
    }
};

template<class F> F* lambda_wrapper<F>::func_ = 0;

// ...
WeightFunc fp = make_function_pointer([](void* param) -> uint64_t { return 0; });