您不能在C ++中使用本地函数。但是，C ++ 11具有lambdas。Lambda基本是像函数一样工作的变量。
Lambda具有类型std::function（实际上并不是很正确，但是在大多数情况下可以假设是）。要使用此类型，您需要#include <functional>。std::function是一个模板，使用语法将返回类型和参数类型作为模板参数std::function<ReturnType(ArgumentTypes)。例如，std::function<int(std::string, float)>一个lambda返回an int并接受两个参数，一个std::string和一个float。最常见的是std::function<void()>，它什么也不返回，也不接受任何参数。
一旦声明了lambda，就可以像普通函数一样使用以下语法对其进行调用 lambda(arguments)。
要定义lambda，请使用语法[captures](arguments){code}（还有其他方法可以执行此操作，但在此不再赘述）。arguments是lambda接受的参数，code是调用lambda时应运行的代码。通常，您放置[=]或[&]捕获。[=]意味着您将捕获由value定义值的范围内的所有变量，这意味着它们将保留声明lambda时具有的值。[&]表示您通过引用捕获了作用域中的所有变量，这意味着它们将始终具有其当前值，但是如果将它们从内存中删除，程序将崩溃。这里有些例子：
#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;
}
您也可以通过指定特定变量的名称来捕获它们。仅指定它们的名称将按值捕获它们，而在&前面指定它们的名称将按引用捕获它们。例如，[=, &foo]将按值捕获所有变量，但foo将通过引用[&, foo]捕获，并且将按引用捕获所有变量，但foo将通过值捕获。您还可以仅捕获特定变量，例如[&foo]将foo通过引用捕获而不会捕获其他变量。您也可以使用完全不捕获任何变量[]。如果尝试在未捕获的lambda中使用变量，则该变量将无法编译。这是一个例子：
#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;
}
您不能更改在lambda内由value捕获的变量的值（由value捕获的变量const在lambda内具有类型）。为此，您需要通过引用捕获变量。这是一个例子：
#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;
}
同样，调用未初始化的lambda是未定义的行为，通常会导致程序崩溃。例如，永远不要这样做：
std::function<void()> lambda;
lambda(); //Undefined behavior because lambda is uninitialized
例子
这是您要使用lambdas在问题中要做的代码：
#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;
}
这是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;
}