Anda tidak dapat memiliki fungsi lokal di C ++. Namun, C ++ 11 memiliki lambdas . Lambdas pada dasarnya adalah variabel yang berfungsi seperti fungsi.
Lambda memiliki tipe std::function( sebenarnya itu tidak sepenuhnya benar , tetapi dalam kebanyakan kasus Anda dapat mengira itu adalah). Untuk menggunakan jenis ini, Anda harus #include <functional>. std::functionadalah templat, dengan argumen templat, tipe pengembalian dan tipe argumen, dengan sintaks std::function<ReturnType(ArgumentTypes). Misalnya, std::function<int(std::string, float)>adalah lambda mengembalikan intdan mengambil dua argumen, satu std::stringdan satu float. Yang paling umum adalahstd::function<void()> , yang tidak menghasilkan apa-apa dan tidak mengambil argumen.
Setelah lambda dideklarasikan, ia dipanggil seperti fungsi normal, menggunakan sintaks lambda(arguments) .
Untuk mendefinisikan lambda, gunakan sintaks [captures](arguments){code}(ada cara lain untuk melakukannya, tapi saya tidak akan menyebutkannya di sini). argumentsadalah argumen yang diambil oleh lambda, dan codemerupakan kode yang harus dijalankan ketika lambda dipanggil. Biasanya Anda menempatkan [=]atau [&]sebagai tangkapan. [=]berarti bahwa Anda menangkap semua variabel dalam lingkup di mana nilai ditentukan oleh nilai, yang berarti bahwa mereka akan menyimpan nilai yang mereka miliki ketika lambda dideklarasikan. [&]berarti bahwa Anda menangkap semua variabel dalam lingkup dengan referensi, yang berarti bahwa mereka akan selalu memiliki nilai saat ini, tetapi jika mereka dihapus dari memori, program akan macet. Berikut ini beberapa contohnya:
#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;
}
Anda juga dapat menangkap variabel tertentu dengan menentukan nama mereka. Hanya menentukan nama mereka akan menangkap mereka dengan nilai, menentukan nama mereka dengan &sebelum akan menangkap mereka dengan referensi. Misalnya, [=, &foo]akan menangkap semua variabel dengan nilai kecuali fooyang akan ditangkap oleh referensi, dan [&, foo]akan menangkap semua variabel dengan referensi kecuali fooyang akan ditangkap oleh nilai. Anda juga dapat menangkap hanya variabel tertentu, misalnya [&foo]akan menangkap foodengan referensi dan tidak akan menangkap variabel lain. Anda juga dapat menangkap tidak ada variabel sama sekali dengan menggunakan []. Jika Anda mencoba menggunakan variabel dalam lambda yang tidak Anda tangkap, itu tidak akan dikompilasi. Berikut ini sebuah contoh:
#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;
}
Anda tidak dapat mengubah nilai variabel yang ditangkap oleh nilai di dalam lambda (variabel yang ditangkap oleh nilai memiliki constjenis di dalam lambda). Untuk melakukannya, Anda perlu menangkap variabel dengan referensi. Inilah contohnya:
#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;
}
Juga, memanggil lambdas tidak diinisialisasi adalah perilaku yang tidak terdefinisi dan biasanya akan menyebabkan program macet. Misalnya, jangan pernah melakukan ini:
std::function<void()> lambda;
lambda(); //Undefined behavior because lambda is uninitialized
Contohnya
Berikut adalah kode untuk apa yang ingin Anda lakukan dalam pertanyaan Anda menggunakan 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;
}
Berikut adalah contoh lambda yang lebih maju:
#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;
}