Non puoi avere funzioni locali in C ++. Tuttavia, C ++ 11 ha lambdas . Le lambda sono sostanzialmente variabili che funzionano come funzioni.
Una lambda ha il tipo std::function(in realtà non è del tutto vero , ma nella maggior parte dei casi puoi supporre che lo sia). Per utilizzare questo tipo, è necessario #include <functional>. std::functionè un modello, prendendo come argomento modello il tipo restituito e i tipi di argomento, con la sintassi std::function<ReturnType(ArgumentTypes). Ad esempio, std::function<int(std::string, float)>è una lambda che restituisce un inte accetta due argomenti, uno std::stringe uno float. Il più comune è std::function<void()>, che non restituisce nulla e non accetta argomenti.
Una volta dichiarata una lambda, viene chiamata proprio come una normale funzione, usando la sintassi lambda(arguments).
Per definire un lambda, usa la sintassi [captures](arguments){code}(ci sono altri modi per farlo, ma non li menzionerò qui). argumentsè quali argomenti prende lambda ed codeè il codice che dovrebbe essere eseguito quando viene chiamato lambda. Di solito metti [=]o [&]come catture. [=]significa che acquisisci tutte le variabili nell'ambito in cui il valore è definito dal valore, il che significa che manterranno il valore che avevano quando è stata dichiarata la lambda. [&]significa che si acquisiscono tutte le variabili nell'ambito per riferimento, il che significa che avranno sempre il loro valore corrente, ma se vengono cancellate dalla memoria il programma andrà in crash. Ecco alcuni esempi:
#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;
}
Puoi anche acquisire variabili specifiche specificandone i nomi. Basta specificare il loro nome per catturarli per valore, specificando il loro nome con un &prima li cattureranno per riferimento. Ad esempio, [=, &foo]acquisirà tutte le variabili in base al valore tranne quelle fooche verranno acquisite per riferimento e [&, foo]acquisirà tutte le variabili in base al riferimento tranne quelle fooche verranno acquisite in base al valore. È anche possibile acquisire solo variabili specifiche, ad esempio [&foo]acquisirà fooper riferimento e non acquisirà altre variabili. Puoi anche non catturare alcuna variabile usando []. Se si tenta di utilizzare una variabile in una lambda che non è stata acquisita, non verrà compilata. Ecco un esempio:
#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;
}
Non è possibile modificare il valore di una variabile catturata dal valore all'interno di un lambda (le variabili catturate dal valore hanno un consttipo all'interno del lambda). Per fare ciò, è necessario acquisire la variabile per riferimento. Ecco un esempio:
#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;
}
Inoltre, chiamare lambda non inizializzati è un comportamento indefinito e di solito causa l'arresto anomalo del programma. Ad esempio, non farlo mai:
std::function<void()> lambda;
lambda(); //Undefined behavior because lambda is uninitialized
Esempi
Ecco il codice per quello che volevi fare nella tua domanda 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;
}
Ecco un esempio più avanzato di 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;
}