Devo passare una lambda di riferimento const.

Question

In genere io uso il seguente schema l'accettazione di una lambda come argomento di una funzione (A passò-by-value classe template):

template <class Function> 
void higherOrderFunction(Function f) { 
    f(); 
} 

Questo copia (la chiusura del) l'argomento? Se è così, c'è qualcosa di sbagliato nell'accettare il lambda di riferimento const, invece?

template <class Function> 
void higherOrderFunction(const Function& f) { 
    f(); 
} 

Un semplice test sembra indicare che questo funziona bene, ma voglio sapere se ci sono delle considerazioni particolari che dovrei essere a conoscenza.

Answer 1

Se si passa per valore, si copierà l'oggetto di chiusura (presumendo che non si definisca il lambda in linea, nel qual caso verrà spostato). Ciò potrebbe essere indesiderato se lo stato è costoso da copiare e non riuscirà a compilare se lo stato non è copiabile.

template <class Function> 
void higherOrderFunction(Function f); 

std::unique_ptr<int> p; 
auto l = [p = std::move(p)] {}; // C++14 lambda with init capture 
higherOrderFunction(l);   // doesn't compile because l is non-copyable 
           // due to unique_ptr member 
higherOrderFunction([p = std::move(p)] {}); // this still works, the closure object is moved 

Se si passa da const riferimento, allora non può passare un lambda mutable che modifica suoi membri di dati come argomento higherOrderFunction() perché un lambda mutable ha un non constoperator(), e non si può invocare che su un const oggetto.

template <class Function> 
void higherOrderFunction(Function const& f); 

int i = 0; 
higherOrderFunction([=]() mutable { i = 0; }); // will not compile 

L'opzione migliore è utilizzare un riferimento di inoltro. Quindi, higherOrderFunction può accettare sia lvalue che rvalue passati al chiamante.

template <class Function> 
void higherOrderFunction(Function&& f) { 
    std::forward<Function>(f)(); 
} 

Ciò consente la compilazione dei casi semplici e di quelli menzionati sopra. Per una discussione sul motivo per cui è necessario utilizzare std::forward, vedere this answer.

Live demo

Answer 2

Una copia è una copia, quindi non è possibile mutare l'originale, potrebbe avere qualche impatto sulle prestazioni quando è coinvolto un sacco di dati:

#include <iostream> 
using namespace std; 

template<typename Fn> 
void call_value(Fn f) { f(); } 
template<typename Fn> 
void call_ref(Fn & f) { f(); } 
template<typename Fn> 
void call_cref(Fn const & f) { f(); } 

struct Data { 
    Data() {} 
    Data(Data const &) { 
    cout << "copy" << endl; 
    } 
    Data(Data &&) { 
    cout << "move" << endl; 
    } 
}; 

int main(int, char **) { 
    Data data; 

    auto capref = [&data]() {}; 
    cout << "capture by value, so we get a "; 
    auto capcp = [data]() {}; 

    cout << " the lambda with a reference ... "; 
    call_value(capref); 
    cout << " could now be called and mutate .. "; 
    call_ref(capref); 
    call_cref(capref); 
    cout << " but won't, as it had to be declared mutable " << endl; 

    cout << "the lambda with an instance: "; 
    call_value(capcp); 
    cout << "but not "; 
    call_ref(capcp); 
    call_cref(capcp); 
    cout << " the reference versions " << endl; 

    bool en = false; 
    auto trigger = [en](bool enable = true) mutable { 
    if (en) { 
     cout << "fire!" << endl; 
    } 
    if (en or enable) { 
     en = true; 
    } 
    }; 
    cout << "won't shoot" << endl; 
    trigger(false); 
    call_value(trigger); 
    trigger(false); 
    call_ref(trigger); 
    cout << "and now ... "; 
    trigger(false); 
    // const ref won't work 
    return 0; 
} 

Guardalo in action.

Da non dimenticare: i lambda sono semplici zucchero sintattici per le classi callable. (Ma estremamente utile)