Вы не можете иметь локальные функции в C ++. Однако в C ++ 11 есть лямбды . Лямбды в основном переменные, которые работают как функции.
У лямбды есть тип std::function(на самом деле это не совсем так , но в большинстве случаев можно предположить, что это так). Чтобы использовать этот тип, вам нужно #include <functional>. std::functionявляется шаблоном, принимающим в качестве аргумента шаблона тип возвращаемого значения и типы аргумента с синтаксисом std::function<ReturnType(ArgumentTypes). Например, std::function<int(std::string, float)>лямбда, возвращающая intи принимающая два аргумента, одинstd::string и один float. Наиболее распространенным является тот std::function<void()>, который ничего не возвращает и не принимает аргументов.
Как только лямбда объявлена, она вызывается как обычная функция, используя синтаксис lambda(arguments) .
Чтобы определить лямбду, используйте синтаксис [captures](arguments){code}(есть другие способы сделать это, но я не буду упоминать их здесь). argumentsВот какие аргументы принимает лямбда, и codeэто код, который должен выполняться при вызове лямбды. Обычно вы ставите [=]или [&]как захватывает. [=]означает, что вы перехватываете все переменные в области действия, в которой значение определяется значением, что означает, что они сохранят значение, которое они имели при объявлении лямбды. [&]означает, что вы захватываете все переменные в области видимости по ссылке, что означает, что они всегда будут иметь свое текущее значение, но если они будут удалены из памяти, программа потерпит крах. Вот некоторые примеры:
#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по ссылке и не захватывать другие переменные. Вы также можете захватить без переменных вообще с помощью []. Если вы попытаетесь использовать переменную в лямбде, которую вы не захватили, она не скомпилируется. Вот пример:
#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;
}
Вы не можете изменить значение переменной, которая была захвачена значением внутри лямбды (переменные, захваченные значением, имеют constтип внутри лямбды). Для этого вам нужно захватить переменную по ссылке. Вот пример:
#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;
}
Кроме того, вызов неинициализированных лямбда-выражений является неопределенным поведением и обычно приводит к сбою программы. Например, никогда не делайте так:
std::function<void()> lambda;
lambda(); //Undefined behavior because lambda is uninitialized
Примеры
Вот код для того, что вы хотели сделать в своем вопросе, используя лямбды:
#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;
}
Вот более продвинутый пример лямбды:
#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;
}