C ++ 'da yerel işlevleriniz olamaz. Bununla birlikte, C ++ 11'in lambdaları vardır . Lambdalar temelde fonksiyonlar gibi çalışan değişkenlerdir.
Bir lambda türü vardır std::function( aslında bu oldukça doğru değildir , ancak çoğu durumda öyle olduğunu varsayabilirsiniz). Bu türü kullanmak için kullanmanız gerekir #include <functional>. std::functionsözdizimi ile dönüş argümanı ve argüman türlerini şablon argümanı olarak alan bir şablondur std::function<ReturnType(ArgumentTypes). Örneğin std::function<int(std::string, float)>, bir döndüren intve bir std::stringve bir olmak üzere iki argüman alan bir lambdadır float. En yaygın olanı, std::function<void()>hiçbir şey döndürmez ve argüman almaz.
Bir lambda bildirildikten sonra, sözdizimi kullanılarak normal bir işlev gibi çağrılır lambda(arguments).
Bir lambda tanımlamak için sözdizimini kullanın [captures](arguments){code}(bunu yapmanın başka yolları vardır, ancak burada bahsetmeyeceğim). argumentslambda'nın aldığı argümanlar ve lambda codeçağrıldığında çalıştırılması gereken koddur. Genellikle koyar [=]ya [&]da yakalarsınız. [=]bu, değerin değerle tanımlandığı kapsamdaki tüm değişkenleri yakaladığınız anlamına gelir. Bu, lambda bildirildiğinde sahip oldukları değeri koruyacakları anlamına gelir. [&]kapsamdaki tüm değişkenleri referans olarak yakaladığınız anlamına gelir, yani her zaman geçerli değerlerine sahip olurlar, ancak bellekten silinirlerse program çökecektir. İşte bazı örnekler:
#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;
}
Belirli değişkenleri adlarını belirterek de yakalayabilirsiniz. Sadece isimlerini belirtmek onları değere göre yakalar, isimlerini daha &önce belirtmek onları referans olarak yakalar. Örneğin, referans tarafından yakalanacak [=, &foo]olanlar hariç tüm değişkenleri değere göre yakalar ve değer tarafından fooyakalanacak [&, foo]olanlar dışında tüm değişkenleri referans olarak yakalar foo. Örnek için de, sadece belirli değişkenler yakalayabilir [&foo]yakalayacaktır fooreferans olarak ve başka hiçbir değişkenleri ele geçirecek. Düğmesini kullanarak hiçbir değişkeni yakalayamazsınız []. Eğer yakalamadığınız bir lambda'da bir değişken kullanmaya çalışırsanız, derlenmez. İşte bir örnek:
#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 içindeki değerle yakalanan bir değişkenin değerini değiştiremezsiniz (değerle yakalanan değişkenlerin constlambda içinde bir türü vardır). Bunu yapmak için değişkeni başvuru ile yakalamanız gerekir. İşte bir örnek:
#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;
}
Ayrıca, başlatılmamış lambdas çağırmak tanımsız bir davranıştır ve genellikle programın çökmesine neden olur. Örneğin, bunu asla yapmayın:
std::function<void()> lambda;
lambda(); //Undefined behavior because lambda is uninitialized
Örnekler
Lamdas kullanarak sorunuzda ne yapmak istediğinize ilişkin kod:
#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;
}
İşte lambda'nın daha gelişmiş bir örneği:
#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;
}