Sollte ich ein Lambda durch const Referenz übergeben.

Question

Normalerweise verwende ich das folgende Muster, wenn eine Lambda als Argument für eine Funktion (A Template-Klasse übergeben-by-Wert) akzeptieren:

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

Ist diese Kopie (die Schließung) das Argument? Wenn ja, ist etwas falsch mit der Annahme der Lambda durch const Referenz stattdessen?

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

Ein einfacher Test scheint darauf hinzudeuten, dass dies funktioniert gut, aber ich möchte wissen, ob es spezielle Überlegungen, die ich bewusst sein sollten.

Answer 1

Wenn Sie nach Wert übergeben, kopieren Sie das Closure-Objekt (vorausgesetzt, Sie definieren das Lambda nicht inline, in diesem Fall wird es verschoben). Dies kann unerwünscht sein, wenn der Zustand teuer zu kopieren ist, und wird nicht kompiliert, wenn der Zustand nicht kopierbar ist.

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 

Wenn Sie mit dem const Verweis übergeben, dann können Sie keine mutable Lambda übergeben, die ihre Datenelemente als Argument für higherOrderFunction() ändert, weil ein mutable Lambda eine nicht constoperator() hat, und Sie können nicht, dass const auf eine aufrufen Objekt.

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

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

Die beste Option ist die Verwendung einer Weiterleitungsreferenz. Dann kann higherOrderFunction entweder lvalues ​​oder rvalues ​​akzeptieren, die der Anrufer übergibt.

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

Dies ermöglicht die einfache Fälle sowie die oben genannten zu kompilieren. Für eine Diskussion, warum std::forward verwendet werden sollte, siehe this answer.

Live demo

Answer 2

Eine Kopie ist eine Kopie, so dass Sie nicht das Original mutieren kann, könnten einige Auswirkungen auf die Leistung haben, wenn eine Menge von Daten beteiligt ist:

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

anzeigen in action.

Nicht vergessen: Lambdas sind nur syntaktischer Zucker für aufrufbare Klassen. (Aber sehr hilfreich)