Richtiger Weg, um ein Lambda als Parameter per Referenz zu erhalten

Was ist der richtige Weg, um eine Funktion zu definieren, die a erhält? int->int Lambda-Parameter nach Referenz?

void f(std::function< int(int) >& lambda);

oder

void f(auto& lambda);

Ich bin mir nicht sicher, ob die letzte Form überhaupt eine legale Syntax ist.

Gibt es andere Möglichkeiten, einen Lambda-Parameter zu definieren?

Sie können keine haben auto Parameter. Sie haben grundsätzlich zwei Möglichkeiten:

Option 1: Verwenden std::function wie du gezeigt hast.

Option 2: Verwenden Sie einen Vorlagenparameter:

template<typename F>
void f(F &lambda) { /* ... */}

Option 2 kann in einigen Fällen effizienter sein, da sie eine potenzielle Heap-Zuweisung für das eingebettete Lambda-Funktionsobjekt vermeiden kann, aber nur dann möglich ist f kann als Template-Funktion in einem Header platziert werden. Es kann auch die Kompilierungszeiten und den I-Cache-Fußabdruck erhöhen, wie dies bei jedem Template der Fall sein kann. Beachten Sie, dass dies möglicherweise auch keine Auswirkungen hat, da das Lambda-Funktionsobjekt, wenn es klein genug ist, inline in dargestellt werden kann std::function Objekt.

ich würde … benutzen template wie:

template<typename Functor>
void f(Functor functor)
{
   cout << functor(10) << endl;
}

int g(int x)
{
    return x * x;
}
int main() 
{
    auto lambda = [] (int x) { cout << x * 50 << endl; return x * 100; };
    f(lambda); //pass lambda
    f(g);      //pass function 
}

Ausgabe:

500
1000
100

Demo: http://www.ideone.com/EayVq

Ich weiß, es ist 7 Jahre her, aber hier ist ein Weg, den sonst niemand erwähnt hat:

void foo(void (*f)(int)){
    std::cout<<"foo"<<std::endl;
    f(1); // calls lambda which takes an int and returns void
}
int main(){
    foo([](int a){std::cout<<"lambda "<<a<<std::endl;});
}

Welche Ausgänge:

foo
lambda 1

Keine Notwendigkeit für Vorlagen oder std::function

Seit C++ 20,

void f(auto& lambda);

funktioniert tatsächlich (es ist eine abgekürzte Funktionsvorlage):

Wenn Platzhaltertypen (entweder auto oder Concept auto) in der Parameterliste einer Funktionsdeklaration oder einer Funktionsvorlagendeklaration erscheinen, die Deklaration eine Funktionsvorlage deklariert und ein erfundener Vorlagenparameter für jeden Platzhalter an die Vorlagenparameterliste angehängt wird

und es entspricht genau Option 2 in @bdonlans Antwort:

template<typename F>
void f(F &lambda) { /* ... */}

void f(auto& lambda);

Das ist knapp. Was tatsächlich kompiliert wird, ist:

#include <cassert>

/*constexpr optional*/ const auto f = [](auto &&lambda)
{
  lambda();
  lambda();
};

int main()
{
  int counter = 0;
  f([&]{ ++counter; });
  assert(counter == 2);
}