smart - C++ 0x lambda, ¿cómo puedo pasar como parámetro?

programar contratos inteligentes

Question

Por favor mire el siguiente código relacionado con C ++ 0x lambda:

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

Recibí un error (en Visual Studio 2010) que la lambda no se pudo convertir al tipo de WEIGHT_FUNC . También sé la respuesta: usando std::function object :

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

Sin embargo, también quiero saber cómo puedo recibir el tipo de lambda SIN usar la std::function . ¿Qué tipo debería ser?

Answer 1

La conversión al puntero de función es relativamente nueva: se introdujo con N3043 el 15 de febrero de 2010.

Mientras que, por ejemplo, GCC 4.5 lo implementa, Visual Studio 10 se lanzó el 12 de abril de 2010 y, por lo tanto, no lo implementó a tiempo. Como James señaló, esto se solucionará en futuras versiones.

Por el momento, debe utilizar una de las soluciones alternativas que se proporcionan aquí.

Técnicamente, algo como la siguiente solución funcionaría, pero sin las plantillas variadas no es divertido generalizarlo (Boost.PP al rescate ...) y no hay una red de seguridad para evitar la captura de lambdas en:

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

Probar con (no probado):

#include <function>

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

No creo que haya otra manera de hacer esto que usar std :: function o equivalente.

Answer 3

Si realmente insistes en no usar la function<> entonces probablemente podrías usar decltype:

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

Aunque realmente no lo recomiendo, ya que te estás limitando drásticamente y ni siquiera sé si se garantiza que dos lambda con la misma firma sean del mismo tipo.