Mengapa lambda C ++ 11 memerlukan kata kunci "bisa berubah" untuk menangkap-oleh-nilai, secara default?

Contoh singkat:

#include <iostream>

int main()
{
    int n;
    [&](){n = 10;}();             // OK
    [=]() mutable {n = 20;}();    // OK
    // [=](){n = 10;}();          // Error: a by-value capture cannot be modified in a non-mutable lambda
    std::cout << n << "\n";       // "10"
}

Pertanyaannya: Mengapa kita perlu mutablekata kunci? Ini sangat berbeda dari melewati parameter tradisional ke fungsi bernama. Apa alasan di baliknya?

Saya mendapat kesan bahwa seluruh poin dari capture-by-value adalah untuk memungkinkan pengguna untuk mengubah sementara - jika tidak, saya hampir selalu lebih baik menggunakan capture-by-reference, bukan?

Adakah pencerahan?

(Omong-omong, saya menggunakan MSVC2010. AFAIK ini seharusnya standar)

Ini membutuhkan mutablekarena secara default, objek fungsi harus menghasilkan hasil yang sama setiap kali dipanggil. Ini adalah perbedaan antara fungsi berorientasi objek dan fungsi menggunakan variabel global, secara efektif.

Kode Anda hampir setara dengan ini:

#include <iostream>

class unnamed1
{
    int& n;
public:
    unnamed1(int& N) : n(N) {}

    /* OK. Your this is const but you don't modify the "n" reference,
    but the value pointed by it. You wouldn't be able to modify a reference
    anyway even if your operator() was mutable. When you assign a reference
    it will always point to the same var.
    */
    void operator()() const {n = 10;}
};

class unnamed2
{
    int n;
public:
    unnamed2(int N) : n(N) {}

    /* OK. Your this pointer is not const (since your operator() is "mutable" instead of const).
    So you can modify the "n" member. */
    void operator()() {n = 20;}
};

class unnamed3
{
    int n;
public:
    unnamed3(int N) : n(N) {}

    /* BAD. Your this is const so you can't modify the "n" member. */
    void operator()() const {n = 10;}
};

int main()
{
    int n;
    unnamed1 u1(n); u1();    // OK
    unnamed2 u2(n); u2();    // OK
    //unnamed3 u3(n); u3();  // Error
    std::cout << n << "\n";  // "10"
}

Jadi Anda bisa menganggap lambdas sebagai menghasilkan kelas dengan operator () yang default ke const kecuali Anda mengatakan bahwa itu bisa berubah.

Anda juga dapat menganggap semua variabel yang ditangkap di dalam [] (secara eksplisit atau implisit) sebagai anggota kelas itu: salinan objek untuk [=] atau referensi ke objek untuk [&]. Mereka diinisialisasi ketika Anda menyatakan lambda Anda seolah-olah ada konstruktor tersembunyi.

Saya mendapat kesan bahwa seluruh poin dari capture-by-value adalah untuk memungkinkan pengguna untuk mengubah sementara - jika tidak, saya hampir selalu lebih baik menggunakan capture-by-reference, bukan?

Pertanyaannya adalah, apakah "hampir"? Kasus penggunaan yang sering muncul adalah untuk mengembalikan atau memberikan lambdas:

void registerCallback(std::function<void()> f) { /* ... */ }

void doSomething() {
  std::string name = receiveName();
  registerCallback([name]{ /* do something with name */ });
}

Saya pikir itu mutablebukan kasus "hampir". Saya menganggap "tangkapan-menurut-nilai" seperti "izinkan saya menggunakan nilainya setelah entitas yang ditangkap mati" daripada "izinkan saya mengubah salinannya". Tapi mungkin ini bisa diperdebatkan.

FWIW, Herb Sutter, seorang anggota terkenal dari komite standardisasi C ++, memberikan jawaban yang berbeda untuk pertanyaan itu dalam Masalah Lambda Correctness and Usability :

Pertimbangkan contoh pembuat jerami ini, di mana programmer menangkap variabel lokal berdasarkan nilai dan mencoba untuk memodifikasi nilai yang ditangkap (yang merupakan variabel anggota dari objek lambda):

int val = 0;
auto x = [=](item e)            // look ma, [=] means explicit copy
            { use(e,++val); };  // error: count is const, need ‘mutable’
auto y = [val](item e)          // darnit, I really can’t get more explicit
            { use(e,++val); };  // same error: count is const, need ‘mutable’

Fitur ini tampaknya telah ditambahkan karena kekhawatiran bahwa pengguna mungkin tidak menyadari bahwa ia mendapatkan salinan, dan khususnya bahwa karena lambda dapat disalin, ia mungkin mengubah salinan lambda yang berbeda.

Makalahnya adalah tentang mengapa ini harus diubah dalam C ++ 14. Ini singkat, ditulis dengan baik, layak dibaca jika Anda ingin tahu "apa yang ada di pikiran [anggota komite]" sehubungan dengan fitur khusus ini.

Anda perlu memikirkan apa jenis penutupan fungsi Lambda Anda. Setiap kali Anda mendeklarasikan ekspresi Lambda, kompiler membuat tipe penutupan, yang tidak lain adalah deklarasi kelas tanpa nama dengan atribut ( lingkungan di mana ekspresi Lambda di mana dinyatakan) dan pemanggilan fungsi ::operator()diimplementasikan. Saat Anda menangkap variabel menggunakan nilai salin , kompiler akan membuat constatribut baru di tipe closure, jadi Anda tidak bisa mengubahnya di dalam ekspresi Lambda karena itu adalah atribut "read-only", itulah alasan mereka menyebutnya " penutupan ", karena dalam beberapa hal, Anda menutup ekspresi Lambda Anda dengan menyalin variabel dari cakupan atas ke dalam cakupan Lambda.mutable, entitas yang ditangkap akan menjadinon-constatribut tipe penutupan Anda. Inilah yang menyebabkan perubahan yang dilakukan dalam variabel yang dapat diubah yang ditangkap oleh nilai, untuk tidak disebarluaskan ke ruang lingkup atas, tetapi tetap di dalam stateful Lambda. Selalu mencoba membayangkan jenis penutupan yang dihasilkan dari ekspresi Lambda Anda, yang banyak membantu saya, dan saya harap itu dapat membantu Anda juga.

Lihat draf ini , di bawah 5.1.2 [expr.prim.lambda], subclause 5:

Tipe penutupan untuk ekspresi lambda memiliki operator fungsi panggilan inline publik (13.5.4) yang parameter dan tipe pengembaliannya dijelaskan oleh parameter-pernyataan-deklarasi-klausa dan masing-masing tipe trailingreturn. Operator pemanggilan fungsi ini dinyatakan const (9.3.1) jika dan hanya jika parameter-deklarasi-klausa lambdaexpression tidak diikuti oleh bisa berubah.

Sunting pada komentar litb: Mungkin mereka memikirkan capture-by-value sehingga perubahan luar pada variabel tidak tercermin di dalam lambda? Referensi bekerja dua arah, jadi itulah penjelasan saya. Tidak tahu apakah itu ada gunanya.

Sunting pada komentar kizzx2: Yang paling sering digunakan lambda adalah sebagai functor untuk algoritma. constNess default memungkinkannya digunakan dalam lingkungan yang konstan, sama seperti constfungsi normal-wajar dapat digunakan di sana, tetapi yang non- constwajar tidak bisa. Mungkin mereka hanya berpikir untuk membuatnya lebih intuitif untuk kasus-kasus itu, yang tahu apa yang terjadi dalam pikiran mereka. :)

Saya mendapat kesan bahwa seluruh poin dari capture-by-value adalah untuk memungkinkan pengguna untuk mengubah sementara - jika tidak, saya hampir selalu lebih baik menggunakan capture-by-reference, bukan?

nadalah tidak temporer. n adalah anggota objek fungsi lambda yang Anda buat dengan ekspresi lambda. Harapan standarnya adalah bahwa memanggil lambda Anda tidak mengubah keadaannya, oleh karena itu ia mencegah Anda memodifikasi secara tidak sengaja n.

Anda harus memahami apa arti penangkapan! itu menangkap bukan lewat argumen! mari kita lihat beberapa contoh kode:

int main()
{
    using namespace std;
    int x = 5;
    int y;
    auto lamb = [x]() {return x + 5; };

    y= lamb();
    cout << y<<","<< x << endl; //outputs 10,5
    x = 20;
    y = lamb();
    cout << y << "," << x << endl; //output 10,20

}

Seperti yang Anda lihat meskipun xtelah diubah ke 20lambda masih kembali 10 ( xmasih 5di dalam lambda) Mengubah xdi dalam lambda berarti mengubah lambda itu sendiri pada setiap panggilan (lambda bermutasi pada setiap panggilan). Untuk menegakkan kebenaran, standar memperkenalkan mutablekata kunci. Dengan menentukan lambda sebagai bisa berubah, Anda mengatakan bahwa setiap panggilan ke lambda dapat menyebabkan perubahan dalam lambda itu sendiri. Coba lihat contoh lain:

int main()
{
    using namespace std;
    int x = 5;
    int y;
    auto lamb = [x]() mutable {return x++ + 5; };

    y= lamb();
    cout << y<<","<< x << endl; //outputs 10,5
    x = 20;
    y = lamb();
    cout << y << "," << x << endl; //outputs 11,20

}

Contoh di atas menunjukkan bahwa dengan membuat lambda bisa berubah, mengubah xdi dalam lambda "mengubah" lambda pada setiap panggilan dengan nilai baru xyang tidak ada hubungannya dengan nilai aktual xdalam fungsi utama

Sekarang ada proposal untuk mengurangi kebutuhan mutabledalam deklarasi lambda: n3424

Untuk memperluas jawaban Puppy, fungsi lambda dimaksudkan sebagai fungsi murni . Itu berarti setiap panggilan yang diberikan set input unik selalu mengembalikan output yang sama. Mari kita tentukan input sebagai himpunan semua argumen plus semua variabel yang ditangkap saat lambda dipanggil.

Dalam fungsi murni, output semata-mata tergantung pada input dan bukan pada beberapa kondisi internal. Karena itu fungsi lambda, jika murni, tidak perlu mengubah kondisinya dan karenanya tidak dapat diubah.

Ketika lambda menangkap dengan referensi, menulis pada variabel yang ditangkap adalah tekanan pada konsep fungsi murni, karena semua fungsi murni harus dilakukan adalah mengembalikan output, meskipun lambda tidak pasti bermutasi karena penulisan terjadi pada variabel eksternal. Bahkan dalam kasus ini penggunaan yang benar menyiratkan bahwa jika lambda dipanggil dengan input yang sama lagi, output akan sama setiap kali, meskipun ada efek samping pada variabel by-ref. Efek samping semacam itu hanyalah cara untuk mengembalikan beberapa input tambahan (mis. Memperbarui penghitung) dan dapat diformulasi ulang menjadi fungsi murni, misalnya mengembalikan tupel alih-alih nilai tunggal.