Dalam C, klausa menangkap Lambda mengawal bagaimana pembolehubah luaran diperkenalkan ke dalam fungsi lambda melalui nilai, rujukan, atau corak lalai. 1. Senarai penangkapan adalah pada permulaan ekspresi lambda dan digunakan untuk menangkap pembolehubah dalam skop luaran untuk penggunaan dalaman lambda. 2. Menangkap melalui nilai ([var]) akan menyalin pembolehubah. Pengubahsuaian dalam lambda tidak akan menjejaskan pemboleh ubah asal. Jika anda perlu mengubah suai salinan, anda perlu menggunakan kata kunci yang boleh berubah. 3. Dengan penangkapan rujukan ([& var]) membolehkan Lambda secara langsung mengubah suai pemboleh ubah asal, tetapi terdapat risiko rujukan yang menggantung. 4. Mod penangkapan lalai [=] secara automatik menangkap semua pembolehubah yang digunakan dengan nilai, [&] secara automatik menangkap dengan rujukan, tetapi harus digunakan dengan berhati -hati untuk mengelakkan kesilapan yang berpotensi. 5. Anda boleh menggunakan campuran tangkapan khusus dengan penangkapan lalai, seperti [=, & x] atau [&, x], tetapi pembolehubah yang sama tidak dapat ditangkap berulang kali dan boleh menjejaskan kebolehbacaan kod. 6. Apabila memilih kaedah penangkapan, anda harus menimbang prestasi dan tingkah laku berdasarkan keperluan anda untuk mengelakkan penyalinan dan penyalahgunaan penangkapan lalai yang tidak perlu.

Dalam C, klausa menangkap Lambda menentukan bagaimana pembolehubah dari skop sekitarnya disediakan di dalam fungsi Lambda. Ia adalah sebahagian daripada ungkapan lambda yang dilampirkan dalam kurungan persegi [] , dan ia mengawal sama ada pembolehubah tersebut ditangkap oleh nilai, dengan rujukan, atau tidak sama sekali.

Apa klausa penangkapan

Klausa penangkapan duduk pada permulaan ekspresi lambda. Tugasnya adalah untuk "menangkap" (iaitu, masuk ke dalam skop lambda) pembolehubah yang wujud di luar lambda tetapi diperlukan untuk pelaksanaannya. Tanpa klausa penangkapan yang betul, anda tidak akan dapat mengakses pembolehubah luaran di dalam badan Lambda anda.

Menangkap pembolehubah mengikut nilai ( [var] )

Apabila anda menangkap pembolehubah dengan nilai, satu salinan pembolehubah itu disimpan di dalam lambda. Ini bermakna perubahan yang dibuat di dalam lambda tidak menjejaskan pemboleh ubah asal.

Contohnya:

 int x = 10;
auto func = [x] () {std :: cout << x; };
x = 20;
func (); // output 10, bukan 20

Di sini, x ditangkap oleh nilai, jadi walaupun selepas menukar x hingga 20, lambda masih memegang nilai asal (10) apabila ia dicipta.

Jika anda ingin mengubah suai salinan yang ditangkap di dalam lambda, anda perlu menambah kata kunci mutable :

 auto func = [x] (int y) mutable {
    x = y;
    std :: cout << x;
};

Sekarang, x boleh diubah dalam lambda - tetapi sekali lagi, hanya salinannya.

Menangkap pembolehubah dengan rujukan ( [&var] )

Menangkap dengan rujukan memberikan akses langsung Lambda kepada pemboleh ubah asal. Sebarang pengubahsuaian di dalam lambda akan menjejaskan pemboleh ubah asal.

Contoh:

 int x = 10;
auto func = [& x] () {x = 30; };
func ();
std :: cout << x; // output 30

Ini berguna apabila anda ingin mengubah keadaan di luar lambda. Tetapi ia juga memperkenalkan risiko - jika Lambda melebih -lebihkan pembolehubah yang ia rujukan, anda berakhir dengan rujukan yang menggantung.

Mod penangkapan lalai: [=] dan [&]

Daripada menyenaraikan setiap pemboleh ubah, anda boleh menggunakan mod tangkapan lalai:

• [=] menangkap semua pembolehubah yang digunakan mengikut nilai
• [&] menangkap semua pembolehubah yang digunakan dengan rujukan

Ini mudah tetapi harus digunakan dengan teliti. Contohnya:

 int a = 1, b = 2;
auto func = [=] () {std :: cout << ab; };

Di sini, kedua -dua a dan b ditangkap oleh nilai secara automatik.

Begitu juga:

 auto func = [&] (int x) {b = x; };

Dalam kes ini, sebarang pemboleh ubah yang dirujuk (seperti b ) akan ditangkap dengan rujukan.

Menggunakan tangkapan lalai kadang-kadang boleh menyembunyikan pepijat halus, terutamanya apabila berurusan dengan lambdas lama atau skop kompleks.

Mencampurkan tangkapan khusus dan lalai

Anda boleh menggabungkan penangkapan khusus dan lalai dalam satu klausa. Contohnya:

• [=, &x] menangkap semuanya mengikut nilai, tetapi menangkap x dengan rujukan
• [&, x] menangkap segala -galanya dengan rujukan, tetapi menangkap x mengikut nilai

Hanya ambil perhatian bahawa sebaik sahaja anda menentukan penangkapan lalai, anda tidak boleh menangkap semula apa-apa pembolehubah dalam klausa yang sama. Juga, mencampurkannya boleh membuat kod lebih sukar untuk dibaca kecuali dilakukan secara sengaja.

Beberapa perkara yang perlu diingat:

• Anda tidak boleh mempunyai kedua -dua [=, x] dan [&, x] dalam senarai tangkapan yang sama.
• Perintah itu tidak penting - [x, =] adalah sama seperti [=, x] .

Bilakah hendak menggunakan yang mana?

Memilih antara penangkapan dengan nilai atau rujukan bergantung pada apa yang anda cuba capai:

• Gunakan penangkapan mengikut nilai apabila anda mahu gambar pembolehubah pada masa lambda dibuat.
• Gunakan penangkapan dengan rujukan apabila anda perlu mencerminkan perubahan yang dibuat di dalam lambda kembali ke pemboleh ubah asal.
• Berhati -hati dengan [=] dan [&] - mereka berkuasa tetapi boleh membawa kepada tingkah laku yang tidak diingini jika disalahgunakan.

Juga, elakkan menangkap objek besar dengan nilai melainkan perlu - menyalinnya mungkin memberi kesan kepada prestasi.

Jadi ya, sijil menangkap Lambda cukup mudah apabila anda memahami bagaimana mereka bekerja, tetapi mudah disalahgunakan jika anda tidak memberi perhatian.

Atas ialah kandungan terperinci Apakah klausa menangkap Lambda di C?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!