Sie können keine lokalen Funktionen in C ++ haben. C ++ 11 hat jedoch Lambdas . Lambdas sind im Grunde genommen Variablen, die wie Funktionen funktionieren.
Ein Lambda hat den Typ std::function( eigentlich stimmt das nicht ganz , aber in den meisten Fällen kann man davon ausgehen). Um diesen Typ zu verwenden, müssen Sie #include <functional>. std::functionist eine Vorlage, die als Vorlagenargument den Rückgabetyp und die Argumenttypen mit der Syntax verwendet std::function<ReturnType(ArgumentTypes). Zum Beispiel std::function<int(std::string, float)>gibt ein Lambda ein zurück intund nimmt zwei Argumente an, eins std::stringund eins float. Die häufigste ist std::function<void()>, dass sie nichts zurückgibt und keine Argumente akzeptiert.
Sobald ein Lambda deklariert ist, wird es wie eine normale Funktion unter Verwendung der Syntax aufgerufen lambda(arguments).
Verwenden Sie zum Definieren eines Lambda die Syntax [captures](arguments){code}(es gibt andere Möglichkeiten, dies zu tun, aber ich werde sie hier nicht erwähnen). argumentsDies sind die Argumente, die das Lambda verwendet, und codeder Code, der ausgeführt werden soll, wenn das Lambda aufgerufen wird. Normalerweise setzen Sie [=]oder [&]als Captures. [=]bedeutet, dass Sie alle Variablen in dem Bereich erfassen, in dem der Wert durch value definiert ist. Dies bedeutet, dass sie den Wert beibehalten, den sie hatten, als das Lambda deklariert wurde. [&]bedeutet, dass Sie alle Variablen im Bereich als Referenz erfassen. Dies bedeutet, dass sie immer ihren aktuellen Wert haben. Wenn sie jedoch aus dem Speicher gelöscht werden, stürzt das Programm ab. Hier sind einige Beispiele:
#include <functional>
#include <iostream>
int main(){
int x = 1;
std::function<void()> lambda1 = [=](){
std::cout << x << std::endl;
};
std::function<void()> lambda2 = [&](){
std::cout << x << std::endl;
};
x = 2;
lambda1(); //Prints 1 since that was the value of x when it was captured and x was captured by value with [=]
lambda2(); //Prints 2 since that's the current value of x and x was captured by value with [&]
std::function<void()> lambda3 = [](){}, lambda4 = [](){}; //I prefer to initialize these since calling an uninitialized lambda is undefined behavior.
//[](){} is the empty lambda.
{
int y = 3; //y will be deleted from the memory at the end of this scope
lambda3 = [=](){
std::cout << y << endl;
};
lambda4 = [&](){
std::cout << y << endl;
};
}
lambda3(); //Prints 3, since that's the value y had when it was captured
lambda4(); //Causes the program to crash, since y was captured by reference and y doesn't exist anymore.
//This is a bit like if you had a pointer to y which now points nowhere because y has been deleted from the memory.
//This is why you should be careful when capturing by reference.
return 0;
}
Sie können bestimmte Variablen auch erfassen, indem Sie deren Namen angeben. Wenn Sie nur ihren Namen angeben, werden sie nach Wert erfasst. Wenn Sie ihren Namen mit einem &Vorher angeben, werden sie als Referenz erfasst. Erfasst beispielsweise [=, &foo]alle Variablen nach Wert, außer foodenen, die als Referenz erfasst werden, und [&, foo]erfasst alle Variablen nach Referenz, außer foodie nach Wert erfasst werden. Sie können auch nur bestimmte Variablen erfassen, z. B. [&foo]als fooReferenz und keine anderen Variablen. Sie können mit überhaupt auch überhaupt keine Variablen erfassen []. Wenn Sie versuchen, eine Variable in einem Lambda zu verwenden, die Sie nicht erfasst haben, wird sie nicht kompiliert. Hier ist ein Beispiel:
#include <functional>
int main(){
int x = 4, y = 5;
std::function<void(int)> myLambda = [y](int z){
int xSquare = x * x; //Compiler error because x wasn't captured
int ySquare = y * y; //OK because y was captured
int zSquare = z * z; //OK because z is an argument of the lambda
};
return 0;
}
Sie können den Wert einer Variablen, die durch den Wert in einem Lambda erfasst wurde, nicht ändern (Variablen, die durch den Wert erfasst werden, haben einen constTyp innerhalb des Lambda). Dazu müssen Sie die Variable als Referenz erfassen. Hier ist ein Beispiel:
#include <functional>
int main(){
int x = 3, y = 5;
std::function<void()> myLambda = [x, &y](){
x = 2; //Compiler error because x is captured by value and so it's of type const int inside the lambda
y = 2; //OK because y is captured by reference
};
x = 2; //This is of course OK because we're not inside the lambda
return 0;
}
Das Aufrufen von nicht initialisierten Lambdas ist ein undefiniertes Verhalten und führt normalerweise zum Absturz des Programms. Tun Sie zum Beispiel niemals Folgendes:
std::function<void()> lambda;
lambda(); //Undefined behavior because lambda is uninitialized
Beispiele
Hier ist der Code für das, was Sie in Ihrer Frage mit Lambdas tun wollten:
#include <functional> //Don't forget this, otherwise you won't be able to use the std::function type
int main(){
std::function<void()> a = [](){
// code
}
a();
return 0;
}
Hier ist ein fortgeschritteneres Beispiel für ein Lambda:
#include <functional> //For std::function
#include <iostream> //For std::cout
int main(){
int x = 4;
std::function<float(int)> divideByX = [x](int y){
return (float)y / (float)x; //x is a captured variable, y is an argument
}
std::cout << divideByX(3) << std::endl; //Prints 0.75
return 0;
}