Você não pode ter funções locais em C ++. No entanto, o C ++ 11 possui lambdas . Lambdas são basicamente variáveis que funcionam como funções.
Um lambda tem o tipo std::function( na verdade isso não é bem verdade , mas na maioria dos casos você pode supor que sim). Para usar esse tipo, você precisa #include <functional>. std::functioné um modelo, tendo como argumento o tipo de retorno e os tipos de argumento, com a sintaxe std::function<ReturnType(ArgumentTypes). Por exemplo, std::function<int(std::string, float)>é um lambda retornando um inte recebendo dois argumentos, um std::stringe um float. O mais comum é std::function<void()>que nada retorna e não aceita argumentos.
Depois que um lambda é declarado, ele é chamado como uma função normal, usando a sintaxe lambda(arguments).
Para definir um lambda, use a sintaxe [captures](arguments){code}(existem outras maneiras de fazer isso, mas não vou mencioná-las aqui). argumentssão os argumentos que o lambda usa e codeé o código que deve ser executado quando o lambda é chamado. Geralmente você coloca [=]ou [&]como captura. [=]significa que você captura todas as variáveis no escopo em que o valor é definido por valor, o que significa que elas manterão o valor que tinham quando o lambda foi declarado. [&]significa que você captura todas as variáveis no escopo por referência, o que significa que elas sempre terão seu valor atual, mas se forem apagadas da memória, o programa falhará. aqui estão alguns exemplos:
#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;
}
Você também pode capturar variáveis específicas especificando seus nomes. Apenas especificar seu nome os capturará por valor, especificando seu nome com um &antes os capturará por referência. Por exemplo, [=, &foo]capturará todas as variáveis por valor, exceto as fooque serão capturadas por referência, e [&, foo]capturará todas as variáveis por referência, exceto as fooque serão capturadas por valor. Você também pode capturar apenas variáveis específicas, por exemplo [&foo], capturará foopor referência e não capturará outras variáveis. Você também pode capturar nenhuma variável usando []. Se você tentar usar uma variável em um lambda que não capturou, ela não será compilada. Aqui está um exemplo:
#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;
}
Você não pode alterar o valor de uma variável que foi capturada por valor dentro de uma lambda (variáveis capturadas por valor têm um consttipo dentro da lambda). Para fazer isso, você precisa capturar a variável por referência. Aqui está um exemplo:
#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;
}
Além disso, chamar lambdas não inicializadas é um comportamento indefinido e geralmente causa falha no programa. Por exemplo, nunca faça isso:
std::function<void()> lambda;
lambda(); //Undefined behavior because lambda is uninitialized
Exemplos
Aqui está o código para o que você queria fazer na sua pergunta usando 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;
}
Aqui está um exemplo mais avançado de um 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;
}