Lambda-Funktion in C++

1. Syntax der Lambda-Funktion in C++
2. Implementieren Sie eine Lambda-Funktion mit einem regulären Funktionszeiger in C++
3. Implementieren Sie eine Lambda-Funktion mit std::function in C++
4. Implementieren Sie eine Lambda-Funktion mit auto in C++
5. Verwendung einer Lambda-Funktion in C++

In diesem Artikel werden die Syntax und Implementierung von Lambda-Funktionen in C++ im Detail sowie relevante Beispiele erläutert.

In C++ werden Lambda-Funktionen oder anonyme Funktionen anonym innerhalb einer anderen Funktion definiert. Es wird inline in den Quellcode geschrieben und als Argument an eine andere Funktion übergeben, die ein aufrufbares Objekt akzeptiert.

Dies macht die Erstellung von Funktionen für C++-Programmierer einfach und schnell. Diese Funktionen haben keinen Namen und werden nicht wiederverwendet.

Syntax der Lambda-Funktion in C++

Allgemeine Syntax:

[Capture List](Parameter List) { Function Body; }

Die Capture List teilt dem Compiler mit, dass eine Lambda-Funktion erstellt wird.

Um eine beliebige Variable im Funktionskörper zu verwenden, müssen wir sie zuerst in der Erfassungsliste erfassen. Andernfalls liegt es außerhalb des Geltungsbereichs des Funktionskörpers.

Auf die erfasste Variable kann entweder als Kopie oder als Referenz zugegriffen werden. Das Erfassen der Variablen wird nicht als Übergabe eines Arguments in einer normalen Funktion angesehen.

Hier wird a durch den Wert erfasst:

auto f = [a]() { return a * 9; };

Und hier wird a durch Referenz erfasst:

auto f = [&a]() { return a++; };

Die Parameterliste nimmt, wie der Name schon sagt, Argumente wie eine normale Funktion auf. Es ist optional zu schreiben, wenn keine Argumente zu übergeben sind.

Mit dem ():

auto call_foo = [x]() { x.foo(); };

Ohne das ():

auto call_foo2 = [x] { x.foo(); };

Diese beiden obigen Lambda-Funktionen haben dieselbe Bedeutung.

Der Function Body enthält den auszuführenden Code wie jede andere reguläre Funktion.

int mul = 5;
auto ans = [mul](int a) { return a * mul; };
std::out << ans(2);

Ausgabe:

5

Beispiel einer Lambda-Funktion in C++:

#include <iostream>
#include <string>
using namespace std;

int main() {
  auto sum = [](int a, int b) { return a + b; };
  cout << "Sum of two integers:" << sum(5, 5) << endl;
  return 0;
}

Ausgabe:

Sum of two integers: 10

Wir haben das Schlüsselwort auto verwendet, um anzuzeigen, dass der Datentyp des Parameters zur Laufzeit bestimmt wird. Dies wird in den folgenden Abschnitten weiter diskutiert.

Implementieren Sie eine Lambda-Funktion mit einem regulären Funktionszeiger in C++

Wir können eine Lambda-Funktion in C++ mit einem Funktionszeiger implementieren.

int main() {
  double (*addNum1)(double, double){[](double a, double b) { return (a + b); }};
  addNum1(1, 2);
}

Ausgabe:

3

Hier ist *addNum1 ein Standardfunktionszeiger, der nur mit einer leeren Erfassungsklausel funktioniert. Danach wird der Parametertyp deklariert - double, double.

Dies wird als Funktionsprototyp bezeichnet. Sie können eine leere Erfassungsklausel beobachten, die angibt, dass eine Lambda-Funktion für den Compiler erstellt wird.

Weiterhin werden in der Parameterliste zwei Variablen übergeben, double a und double b. Und innerhalb des Funktionskörpers wird die Hinzufügung dieser Variablen zurückgegeben.

Nach dem Beenden der Hauptfunktion wird die Funktion addNum(1,2) aufgerufen und liefert als Output 3 zurück.

Implementieren Sie eine Lambda-Funktion mit std::function in C++

std::function addNum{[](double a, double b) { return (a + b); }};
addNumbers2(3, 4);

Ausgabe:

7

Die std::function übergibt Lambda-Funktionen als Parameter und Rückgabewerte. Es ermöglicht Ihnen, die genauen Typen für die Argumentliste und den Rückgabewert in der Vorlage zu deklarieren.

Hier werden zwei Variablen in der Parameterliste übergeben, double a und double b. Und innerhalb des Funktionskörpers wird die Hinzufügung dieser Variablen zurückgegeben.

Nach dem Beenden der Hauptfunktion wird die Funktion addNum(1,2) aufgerufen und liefert als Output 7 zurück.

Implementieren Sie eine Lambda-Funktion mit auto in C++

auto addNum{[](double a, double b) { return (a + b); }};
addNum(5, 6);
return 0;

Ausgabe:

11

Wir können Lambdas nicht direkt verwenden, da sie keinen Typ haben. Wenn wir also eine Lambda-Funktion erstellen, erstellt der Compiler einen eindeutigen Parametertyp.

Obwohl wir nicht wissen, um welche Art von Lambda-Funktion es sich handelt, gibt es zahlreiche Methoden, um sie für die Verwendung nach der Definition zu speichern. Die einzige Methode, um den echten Typ des Lambdas zu verwenden, ist auto.

Lambda-Funktionen können überall im C++-Programm verwendet werden, nachdem sie als auto deklariert wurden.

Verwendung einer Lambda-Funktion in C++

Lambda-Ausdrücke werden häufig verwendet, um Algorithmen zu kapseln, um sie an eine andere Funktion zu übergeben.

Eine Lambda-Funktion kann direkt nach der Definition ausgeführt werden: [ ](double a, double b).

{return (a + b)}();  // immediately executed lambda expression

{ return (a + b) }  // simple code block

Wie wir sehen können, sind Lambda-Ausdrücke ein effektives Werkzeug zum Umstrukturieren komplizierter Funktionen.

Der Prozess der expliziten Parametrisierung kann dann Schritt für Schritt durchgeführt werden, mit zwischenzeitlichen Tests. Nachdem der Codeblock entsprechend parametriert wurde, verlagern Sie ihn an einen externen Ort und machen ihn zu einer normalen Funktion.

Lambda-Ausdrücke ermöglichen auch das Erstellen benannter verschachtelter Funktionen, wodurch unnötige Logik entfernt werden kann. Wenn Sie einer anderen Funktion eine nicht triviale Funktion als Parameter übergeben, ist die Verwendung benannter Lambdas für die Augen einfacher.

auto algo = [&](double x, double m, double b) -> double { return mx + b; };
int l = algorithm(1, 2, 3), m = algorithm(4, 5, 6);