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 Callba         


        

Answer 1

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

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

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.