Ekspresi Lambda adalah cara yang mudah untuk menulis fungsi inline di C, terutamanya untuk lulus logik kecil sebagai parameter ke fungsi lain, seperti fungsi dalam algoritma STL. Sintaks asasnya termasuk senarai penangkapan (dalam kurungan persegi), senarai parameter (pilihan) dan badan fungsi (dalam kurungan keriting), seperti: [menangkap] (parameter) -> return_type {// function body}. 1. Senarai tangkapan menentukan pembolehubah luaran yang dapat diakses oleh lambda dan kaedah aksesnya, seperti [x] yang ditangkap oleh nilai, [& x] ditangkap oleh rujukan; 2. Jenis pulangan boleh ditinggalkan, dan jika badan fungsi hanya mengandungi satu pernyataan pulangan, ia akan diperolehi oleh pengkompil; 3. Gunakan kata kunci yang boleh berubah untuk mengubah suai pembolehubah yang ditangkap oleh nilai; 4. Kegunaan umum termasuk digabungkan dengan algoritma STL, seperti predikat atau operasi di std :: rove_if atau std :: sort; 5. Lambda sesuai untuk logik pendek, satu kali, dan logik kompleks atau multiplexed harus menggunakan fungsi atau functor biasa. Adalah disyorkan untuk memastikan Lambda ringkas, mengelakkan penangkapan pembolehubah yang berlebihan, dan gunakan penangkapan rujukan dengan berhati -hati untuk mengelakkan rujukan yang menggantung.

Ekspresi Lambda di CA adalah cara yang mudah untuk menulis fungsi inline - terutamanya berguna apabila melewati bit kecil logik sebagai argumen kepada fungsi lain, seperti yang terdapat dalam algoritma STL. Jika anda telah melihat kod dengan kurungan persegi dan => , dan tertanya -tanya apa yang sedang berlaku, tutorial ini harus membersihkan perkara.

Sintaks asas lambda

Ekspresi lambda bermula dengan klausa penangkapan (dalam kurungan persegi), diikuti dengan senarai parameter (pilihan), maka badan di dalam pendakap keriting.

Inilah struktur umum:

 [menangkap] (parameter) -> return_type {
    // badan fungsi
}

Anda tidak perlu menentukan jenis kembali - pengkompil boleh menyimpulkannya jika badan mempunyai pernyataan pulangan yang mudah.

Contohnya:

 Auto Multiply = [] (int a, int b) {
    kembali a * b;
};

Ini mewujudkan lambda yang menggandakan dua bilangan bulat dan menyimpannya dalam pembolehubah yang dipanggil multiply . Anda boleh memanggilnya seperti fungsi biasa: multiply(3, 4) Pulangan 12.

Menangkap pembolehubah dari skop sekitarnya

Klausa penangkapan memberitahu Lambda yang pembolehubah dari skop luar yang dapat diakses, dan bagaimana (dengan nilai atau rujukan).

• [x] menangkap x mengikut nilai (salinan)
• [&x] menangkap x dengan rujukan
• [&] menangkap semua yang digunakan dengan rujukan
• [=] menangkap semua yang digunakan dengan nilai

Contoh:

 int offset = 5;
Auto addOffset = [offset] (int value) {
    pulangan nilai offset;
};

Dalam kes ini, offset disalin ke Lambda. Mengubah offset kemudian tidak akan menjejaskan nilai di dalam lambda.

Jika anda ingin menukar nilai yang ditangkap mengikut nilai, anda perlu menandakan Lambda Mutable:

 int count = 0;
kenaikan auto = [count] () mutable {
    kiraan pulangan;
};

Sekarang setiap panggilan untuk increment() meningkatkan salinan count sendiri.

Menggunakan lambdas dengan algoritma STL

Salah satu kegunaan yang paling biasa untuk lambdas adalah seperti ramalan atau operasi dalam algoritma STL.

Katakan anda mempunyai vektor nombor dan anda ingin mengeluarkan semua nombor walaupun:

 std :: vektor <int> nombor = {1, 2, 3, 4, 5, 6};

nombor.erase (
    std :: rove_if (angka.begin (), angka.end (), [] (int n) {
        kembali n % 2 == 0;
    }),
    nombor.end ()
);

Di sini, pemeriksaan Lambda jika nombor juga dan kembali benar bagi mereka yang akan dikeluarkan. Ia pendek, mandiri, dan mengelakkan untuk menentukan fungsi yang berasingan.

Satu lagi penggunaan biasa adalah disusun dengan logik tersuai:

 std :: vector <std :: string> names = {"zoe", "Alice", "bob"};
std :: sort (names.begin (), names.end (), [] (const std :: string & a, const std :: string & b) {
    kembali A.Length () <b.length ();
});

Ini jenis rentetan berdasarkan panjangnya dan bukannya susunan abjad.

Bila Menggunakan Fungsi Lambdas vs Biasa

Lambdas adalah yang terbaik untuk kepingan logik kecil yang tidak perlu digunakan semula. Mereka membuat kod anda lebih mudah dibaca apabila logik ditambah dengan operasi lain.

Sebaliknya, jika logiknya kompleks atau digunakan semula di beberapa tempat, melekat dengan fungsi atau fungsi normal.

Beberapa petua:

• Pastikan Lambdas Pendek dan Fokus
• Elakkan menangkap terlalu banyak pembolehubah kecuali perlu
• Gunakan mutable hanya apabila anda benar -benar perlu mengubah suai salinan
• Lebih suka menangkap dengan rujukan hanya apabila diperlukan - sebaliknya lebih suka dengan nilai untuk mengelakkan rujukan menggantung

Itulah teras bekerja dengan Lambdas di c. Mereka berkuasa tetapi mudah untuk keterlaluan - menggunakannya di mana mereka memudahkan kod tanpa menjadikannya lebih sukar untuk diikuti.

Atas ialah kandungan terperinci C Tutorial mengenai Ekspresi Lambda. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!