Passando capturando lambda como ponteiro de função

É possível passar uma função lambda como um ponteiro de função? Nesse caso, devo estar fazendo algo incorretamente porque estou recebendo um erro de compilação.

Considere o seguinte exemplo

using DecisionFn = bool(*)();

class Decide
{
public:
    Decide(DecisionFn dec) : _dec{dec} {}
private:
    DecisionFn _dec;
};

int main()
{
    int x = 5;
    Decide greaterThanThree{ [x](){ return x > 3; } };
    return 0;
}

Quando tento compilar isso , recebo o seguinte erro de compilação:

In function 'int main()':
17:31: error: the value of 'x' is not usable in a constant expression
16:9:  note: 'int x' is not const
17:53: error: no matching function for call to 'Decide::Decide(<brace-enclosed initializer list>)'
17:53: note: candidates are:
9:5:   note: Decide::Decide(DecisionFn)
9:5:   note: no known conversion for argument 1 from 'main()::<lambda()>' to 'DecisionFn {aka bool (*)()}'
6:7:   note: constexpr Decide::Decide(const Decide&)
6:7:   note: no known conversion for argument 1 from 'main()::<lambda()>' to 'const Decide&'
6:7:   note: constexpr Decide::Decide(Decide&&)
6:7:   note: no known conversion for argument 1 from 'main()::<lambda()>' to 'Decide&&'

Essa é uma mensagem de erro para digerir, mas acho que o que estou tirando disso é que o lambda não pode ser tratado como um constexprmodo, portanto, não posso transmiti-lo como um ponteiro de função? Eu tentei fazer xconst também, mas isso não parece ajudar.

Um lambda só pode ser convertido em um ponteiro de função se não capturar, como mostra a seção padrão do C ++ 11 5.1.2 [expr.prim.lambda] ( ênfase minha ):

O tipo de fechamento para uma expressão lambda sem captura lambda possui uma função pública de conversão const não virtual não explícita em ponteiro para função com o mesmo parâmetro e tipos de retorno que o operador de chamada de função do tipo de fechamento. O valor retornado por essa função de conversão deve ser o endereço de uma função que, quando chamada, tem o mesmo efeito que a chamada do operador de chamada de função do tipo de fechamento.

Observe que o cppreference também aborda isso em sua seção sobre funções do Lambda .

Portanto, as seguintes alternativas funcionariam:

typedef bool(*DecisionFn)(int);

Decide greaterThanThree{ []( int x ){ return x > 3; } };

e assim seria:

typedef bool(*DecisionFn)();

Decide greaterThanThree{ [](){ return true ; } };

e como 5gon12eder aponta, você também pode usá-lo std::function, mas observe que std::functioné muito pesado , portanto, não é uma troca barata.

A resposta de Shafik Yaghmour explica corretamente por que o lambda não pode ser passado como ponteiro de função se tiver uma captura. Eu gostaria de mostrar duas correções simples para o problema.

1. Use em std::functionvez de ponteiros de função bruta.

   Esta é uma solução muito limpa. Observe, no entanto, que ele inclui alguma sobrecarga adicional para o apagamento do tipo (provavelmente uma chamada de função virtual).

   #include <functional>
   #include <utility>
   
   struct Decide
   {
     using DecisionFn = std::function<bool()>;
     Decide(DecisionFn dec) : dec_ {std::move(dec)} {}
     DecisionFn dec_;
   };
   
   int
   main()
   {
     int x = 5;
     Decide greaterThanThree { [x](){ return x > 3; } };
   }

2. Use uma expressão lambda que não captura nada.

   Como seu predicado é realmente apenas uma constante booleana, o seguinte rapidamente resolveria o problema atual. Veja esta resposta para uma boa explicação de por que e como isso está funcionando.

   // Your 'Decide' class as in your post.
   
   int
   main()
   {
     int x = 5;
     Decide greaterThanThree {
       (x > 3) ? [](){ return true; } : [](){ return false; }
     };
   }

Expressões lambda, mesmo as capturadas, podem ser manipuladas como um ponteiro de função (ponteiro para a função membro).

É complicado porque uma expressão lambda não é uma função simples. Na verdade, é um objeto com um operador ().

Quando você é criativo, pode usar isso! Pense em uma classe "function" no estilo de std :: function. Se você salvar o objeto, também poderá usar o ponteiro de função.

Para usar o ponteiro de função, você pode usar o seguinte:

int first = 5;
auto lambda = [=](int x, int z) {
    return x + z + first;
};
int(decltype(lambda)::*ptr)(int, int)const = &decltype(lambda)::operator();
std::cout << "test = " << (lambda.*ptr)(2, 3) << std::endl;

Para criar uma classe que possa começar a funcionar como uma "std :: function", primeiro você precisa de uma classe / estrutura que possa armazenar o objeto e o ponteiro de função. Você também precisa de um operador () para executá-lo:

// OT => Object Type
// RT => Return Type
// A ... => Arguments
template<typename OT, typename RT, typename ... A>
struct lambda_expression {
    OT _object;
    RT(OT::*_function)(A...)const;

    lambda_expression(const OT & object)
        : _object(object), _function(&decltype(_object)::operator()) {}

    RT operator() (A ... args) const {
        return (_object.*_function)(args...);
    }
};

Com isso, agora você pode executar lambdas capturadas e não capturadas, exatamente como você está usando o original:

auto capture_lambda() {
    int first = 5;
    auto lambda = [=](int x, int z) {
        return x + z + first;
    };
    return lambda_expression<decltype(lambda), int, int, int>(lambda);
}

auto noncapture_lambda() {
    auto lambda = [](int x, int z) {
        return x + z;
    };
    return lambda_expression<decltype(lambda), int, int, int>(lambda);
}

void refcapture_lambda() {
    int test;
    auto lambda = [&](int x, int z) {
        test = x + z;
    };
    lambda_expression<decltype(lambda), void, int, int>f(lambda);
    f(2, 3);

    std::cout << "test value = " << test << std::endl;
}

int main(int argc, char **argv) {
    auto f_capture = capture_lambda();
    auto f_noncapture = noncapture_lambda();

    std::cout << "main test = " << f_capture(2, 3) << std::endl;
    std::cout << "main test = " << f_noncapture(2, 3) << std::endl;

    refcapture_lambda();

    system("PAUSE");
    return 0;
}

Este código funciona com o VS2015

Atualização 04.07.17:

template <typename CT, typename ... A> struct function
: public function<decltype(&CT::operator())(A...)> {};

template <typename C> struct function<C> {
private:
    C mObject;

public:
    function(const C & obj)
        : mObject(obj) {}

    template<typename... Args> typename 
    std::result_of<C(Args...)>::type operator()(Args... a) {
        return this->mObject.operator()(a...);
    }

    template<typename... Args> typename 
    std::result_of<const C(Args...)>::type operator()(Args... a) const {
        return this->mObject.operator()(a...);
    }
};

namespace make {
    template<typename C> auto function(const C & obj) {
        return ::function<C>(obj);
    }
}

int main(int argc, char ** argv) {
   auto func = make::function([](int y, int x) { return x*y; });
   std::cout << func(2, 4) << std::endl;
   system("PAUSE");
   return 0;
}

A captura de lambdas não pode ser convertida em ponteiros de função, pois esta resposta apontou.

No entanto, muitas vezes é muito difícil fornecer um ponteiro de função para uma API que aceita apenas um. O método mais citado para fazer isso é fornecer uma função e chamar um objeto estático.

static Callable callable;
static bool wrapper()
{
    return callable();
}

Isso é entediante. Levamos essa idéia adiante e automatizamos o processo de criação wrappere facilitar a vida.

#include<type_traits>
#include<utility>

template<typename Callable>
union storage
{
    storage() {}
    std::decay_t<Callable> callable;
};

template<int, typename Callable, typename Ret, typename... Args>
auto fnptr_(Callable&& c, Ret (*)(Args...))
{
    static bool used = false;
    static storage<Callable> s;
    using type = decltype(s.callable);

    if(used)
        s.callable.~type();
    new (&s.callable) type(std::forward<Callable>(c));
    used = true;

    return [](Args... args) -> Ret {
        return Ret(s.callable(std::forward<Args>(args)...));
    };
}

template<typename Fn, int N = 0, typename Callable>
Fn* fnptr(Callable&& c)
{
    return fnptr_<N>(std::forward<Callable>(c), (Fn*)nullptr);
}

E use-o como

void foo(void (*fn)())
{
    fn();   
}

int main()
{
    int i = 42;
    auto fn = fnptr<void()>([i]{std::cout << i;});
    foo(fn);  // compiles!
}

Viver

Isto é essencialmente declarar uma função anônima em cada ocorrência de fnptr .

Observe que as invocações de fnptrsobrescrever os callablecallables fornecidos anteriormente escritos do mesmo tipo. Nós remediar esta situação, até certo ponto, com o intparâmetro N.

std::function<void()> func1, func2;
auto fn1 = fnptr<void(), 1>(func1);
auto fn2 = fnptr<void(), 2>(func2);  // different function

Um atalho para usar um lambda como um ponteiro de função C é este:

"auto fun = +[](){}"

Usando Curl como exemplo ( informações de depuração de curl )

auto callback = +[](CURL* handle, curl_infotype type, char* data, size_t size, void*){ //add code here :-) };
curl_easy_setopt(curlHande, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curlHande,CURLOPT_DEBUGFUNCTION,callback);

Embora a abordagem do modelo seja inteligente por vários motivos, é importante lembrar o ciclo de vida do lambda e as variáveis ​​capturadas. Se alguma forma de ponteiro lambda for usada e o lambda não for uma continuação descendente, somente um lambda de cópia [=] deve ser usado. Ou seja, mesmo assim, capturar um ponteiro para uma variável na pilha não é SEGURO se a vida útil desses ponteiros capturados (desenrolar a pilha) for menor que a vida útil da lambda.

Uma solução mais simples para capturar um lambda como um ponteiro é:

auto pLamdba = new std::function<...fn-sig...>([=](...fn-sig...){...});

por exemplo, new std::function<void()>([=]() -> void {...}

Lembre-se de mais tarde, delete pLamdbapara garantir que você não vaze a memória lambda. O segredo para perceber aqui é que os lambdas podem capturar lambdas (pergunte a si mesmo como isso funciona) e também que, para std::functionfuncionar genericamente, a implementação lambda precisa conter informações internas suficientes para fornecer acesso ao tamanho dos dados lambda (e capturados) ( é por isso que deletedeve funcionar [executando destruidores de tipos capturados]).

Não é uma resposta direta, mas uma pequena variação para usar o padrão de modelo "functor" para ocultar as especificidades do tipo lambda e manter o código agradável e simples.

Eu não tinha certeza de como você queria usar a classe decide, então tive que estender a classe com uma função que a utiliza. Veja o exemplo completo aqui: https://godbolt.org/z/jtByqE

A forma básica da sua classe pode ser assim:

template <typename Functor>
class Decide
{
public:
    Decide(Functor dec) : _dec{dec} {}
private:
    Functor _dec;
};

Onde você passa o tipo da função como parte do tipo de classe usado como:

auto decide_fc = [](int x){ return x > 3; };
Decide<decltype(decide_fc)> greaterThanThree{decide_fc};

Mais uma vez, eu não sabia por que você xestava capturando , fazia mais sentido (para mim) ter um parâmetro que você passasse para o lambda) para que você pudesse usar como:

int result = _dec(5); // or whatever value

Veja o link para um exemplo completo

Como foi mencionado pelos outros, você pode substituir a função Lambda em vez do ponteiro de função. Eu estou usando esse método na minha interface C ++ para o solucionador de F77 ODE RKSUITE.

//C interface to Fortran subroutine UT
extern "C"  void UT(void(*)(double*,double*,double*),double*,double*,double*,
double*,double*,double*,int*);

// C++ wrapper which calls extern "C" void UT routine
static  void   rk_ut(void(*)(double*,double*,double*),double*,double*,double*,
double*,double*,double*,int*);

//  Call of rk_ut with lambda passed instead of function pointer to derivative
//  routine
mathlib::RungeKuttaSolver::rk_ut([](double* T,double* Y,double* YP)->void{YP[0]=Y[1]; YP[1]= -Y[0];}, TWANT,T,Y,YP,YMAX,WORK,UFLAG);