Quale modo di invocare lambda in C++ è il più idiomatico?

Question

Ho notato che lambdas funzionano entrambi utilizzando i puntatori di funzione e il tipo dedicato function utilizzando g++.

#include <functional> 

typedef int(*fptr)(int, int); 

int apply_p(fptr f, int a, int b) { 
    return f(a, b); 
} 

int apply_f(std::function<int(int, int)> f, int a, int b) { 
    return f(a, b); 
} 

void example() { 
    auto add = [](int a, int b) -> int { 
    return a + b; 
    }; 

    apply_p(add, 2, 3); // doesn't give an error like I'd expect it to 
    apply_f(add, 2, 3); 
} 

La mia domanda è: quali di questi sono più idiomatici da usare? E quali sono i pericoli e/oi benefici dell'usare l'uno sull'altro?

Answer 1

Ho notato che lambda sia il lavoro usando puntatori a funzione così come il function tipo dedicato

Se il lambda non catturare qualsiasi cosa, allora può decadere ad un puntatore a funzione.

Quali di questi sono i più idiomatici da usare?

Nessuno dei due. Utilizzare function se si desidera archiviare un oggetto callable arbitrario. Se si desidera solo per creare e utilizzare una sola, tenerlo generico:

template <typename Function> 
int apply(Function && f, int a, int b) { 
    return f(a,b); 
} 

Si può andare oltre e rendere il tipo di ritorno e l'argomento (s) generici; Lo lascerò come esercizio.

E quali sono i pericoli e/o i vantaggi dell'utilizzo degli uni sugli altri?

La versione del puntatore a funzione funziona solo con funzioni (non membro o statiche) e lambda non acquisiti e non consente il passaggio di nessuno stato; solo la funzione stessa e i suoi argomenti. Il tipo function può includere qualsiasi tipo di oggetto chiamabile, con o senza stato, quindi è generalmente più utile. Tuttavia, questo ha un costo in fase di esecuzione: per nascondere il tipo spostato, chiamarlo coinvolgerà una chiamata di funzione virtuale (o simile); e potrebbe aver bisogno dell'allocazione dinamica della memoria per contenere un tipo grande.

Answer 2

direi (C++ 14)

template <class Functor, class... Args> 
decltype(auto) apply_functor(Functor&& f, Args&&... args) { 
    return std::forward<Functor>(f)(std::forward<Args>(args)...); 
} 

o C++ 11:

template <class Functor, class... Args> 
auto apply_functor(Functor&& f, Args&&... args) ->decltype(std::forward<Functor>(f)(std::forward<Args>(args)...)) { 
    return std::forward<Functor>(f)(std::forward<Args>(args)...); 
} 

Answer 3

In caso di dubbio, preferiscono std::function:

1. La sintassi è molto più semplice e coerente con altri tipi, si consideri ad es

   typedef std::function<int (int, int)> MyAddFunction; 
   

   e

   typedef int (*MyAddFunction)(int, int); 
   

2. È più generico (in realtà può prendere un lambda o una funzione C normale o un funtore)

3. È più sicuro tipo

   apply_p(0, 0, 0); // probably crashes at runtime, dereferences null pointer 
   apply_f(0, 0, 0); // doesn't even compile