C ++ 11'in lambda'sı, varsayılan olarak, değere göre yakalama için “mutable” anahtar sözcüğünü gerektirir?

Kısa bir örnek:

#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"
}

Soru: mutableAnahtar kelimeye neden ihtiyacımız var ? Geleneksel parametrelerden adlandırılmış işlevlere geçişten oldukça farklıdır. Gerideki mantık nedir?

Ben değere göre ele geçirmenin tüm noktasının, kullanıcının geçici olarak değiştirmesine izin vermek olduğu izlenimi altındaydım - aksi halde, her zaman referansla yakala özelliğini kullanmaktan daha iyiyim, değil mi?

Aydınlanma var mı?

(Bu arada MSVC2010 kullanıyorum. AFAIK bu standart olmalı)

Bu gerektiren mutablevarsayılan olarak bir işlev nesne aynı sonucu denir her zaman üretmelidir çünkü. Bu, nesne yönelimli bir işlev ile genel bir değişken kullanan bir işlev arasındaki farktır.

Kodunuz neredeyse buna eşittir:

#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"
}

Böylece lambdas, değişebilir olduğunu söylemediğiniz sürece const varsayılan olarak varsayılan bir operatör () ile bir sınıf oluşturmak olarak düşünebilirsiniz.

Ayrıca [] içinde yakalanan tüm değişkenleri (açık veya kapalı olarak) bu sınıfın üyeleri olarak düşünebilirsiniz: [=] için nesnelerin kopyalarını veya [&] için nesnelere referanslar. Lambda'nızı gizli bir kurucu varmış gibi ilan ettiğinizde başlatılırlar.

Ben değere göre ele geçirmenin tüm noktasının, kullanıcının geçici olarak değiştirmesine izin vermek olduğu izlenimi altındaydım - aksi halde, her zaman referansla yakala özelliğini kullanmaktan daha iyiyim, değil mi?

Soru şu, "neredeyse" mi? Sık kullanılan bir kullanım durumunun lambdaları iade etmek veya geçmek gibi görünmektedir:

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

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

Bence bu mutable"neredeyse" bir durum değil. "Değere göre yakala" gibi "yakalanan varlık öldükten sonra değerini kullanmama izin ver" yerine "bir kopyasını değiştirmeme izin ver" olarak değerlendiriyorum. Ama belki de bu tartışılabilir.

C ++ standardizasyon komitesinin tanınmış bir üyesi olan Herb Sutter, FWIW, Lambda Düzeltme ve Kullanılabilirlik Sorunlarında bu soruya farklı bir cevap veriyor :

Programcının yerel bir değişkeni değere göre yakaladığı ve yakalanan değeri (lambda nesnesinin bir üye değişkeni olan) değiştirmeye çalıştığı bu hasır adam örneğini düşünün:

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’

Bu özellik, kullanıcının bir kopyasını aldığını fark etmeyebileceği ve özellikle lambdaların kopyalanabilmesi nedeniyle farklı bir lambda kopyasını değiştirebileceği endişesinden eklenmiş gibi görünüyor.

Makalesi, bunun neden C ++ 14'te değiştirilmesi gerektiğiyle ilgili. Bu özel özellik ile ilgili olarak "[komite üyesi] zihinlerde ne olduğunu" bilmek istiyorsanız, kısa, iyi yazılmış, okumaya değer.

Lambda fonksiyonunuzun kapanma tipinin ne olduğunu düşünmeniz gerekir . Bir Lambda ifadesini her bildirdiğinizde, derleyici, niteliklerle ( bildirilen Lambda ifadesinin bulunduğu ortam ) ve işlev çağrısıyla adlandırılmamış bir sınıf bildiriminden daha az bir şey olmayan bir kapatma türü oluşturur , yakalanan varlık, kapatmanızın bir özelliği haline gelir yazın. Bu, değer tarafından yakalanan değişken değişkente yapılan değişikliklerin üst kapsama yayılmamasına, ancak durumsal Lambda'nın içinde kalmasına neden olan şeydir. Her zaman bana çok yardımcı olan Lambda ifadenizin ortaya çıkan kapanış tipini hayal etmeye çalışın ve umarım size de yardımcı olabilir.::operator() uygulandığı . Kullandığınız bir değişken yakaladığınızda kopyasını değer-ile- , derleyici yeni yaratacak constsen Lambda ifade içinde bunu değiştiremezsiniz bu yüzden sebebi bir "salt okunur" özelliği, çünkü kapatma türü niteliğini onlar " kapatma " deyin , çünkü bir şekilde, değişkenleri üst kapsamdan Lambda kapsamına kopyalayarak Lambda ifadenizi kapatıyorsunuz.mutablenon-const

5.1.2 [expr.prim.lambda], alt madde 5 uyarınca bu taslağa bakınız :

Bir lambda ifadesi için kapatma tipinde, parametreleri ve dönüş tipi sırasıyla lambda-ifadesinin parametre-bildirim-cümlecik ve izleyen dönüş tipi tarafından açıklanan genel bir satır içi işlev çağrısı operatörü (13.5.4) vardır. Bu işlev çağrısı işleci, yalnızca lambdaexpression'un parametre bildirimi yan tümcesini değiştirilebiliyorsa const (9.3.1) olarak bildirilir.

Litb'nin yorumunda düzenleyin: Değişkenlerde yapılan dış değişikliklerin lambda içine yansımaması için belki de değere göre yakalamayı düşündüler? Referanslar her iki şekilde de çalışır, bu yüzden bu benim açıklamam. Yine de iyi olup olmadığını bilmiyorum.

Kizzx2'nin yorumunda düzenleme: Bir lambda'nın en çok ne zaman kullanılacağı, algoritmalar için bir işlev olarak kullanılır. Varsayılan constness, normal constkalifiye işlevlerin orada kullanılabileceği gibi sabit bir ortamda kullanılmasına izin verir , ancak constkalifiye olmayanlar kullanamaz. Belki de sadece akıllarında neler olduğunu bilen vakalar için daha sezgisel hale getirmeyi düşündüler. :)

Ben değere göre ele geçirmenin tüm noktasının, kullanıcının geçici olarak değiştirmesine izin vermek olduğu izlenimi altındaydım - aksi halde, her zaman referansla yakala özelliğini kullanmaktan daha iyiyim, değil mi?

nolduğu değil geçici. n, lambda ifadesi ile oluşturduğunuz lambda-function-object öğesinin bir üyesidir. Varsayılan beklenti, lambda'nızı çağırmanın durumunu değiştirmemesidir, bu nedenle yanlışlıkla değiştirmenizi önlemek için sabittir n.

Yakalamanın ne anlama geldiğini anlamalısınız! tartışmayı geçmeyi değil! bazı kod örneklerine bakalım:

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

}

Gördüğünüz gibi lambda xdeğiştirilmiş olsa bile 20hala 10 geri dönüyor ( xhala 5lambda xiçinde ) Lambda'nın içinde değiştirmek, her çağrıda lambda'nın kendisini değiştirmek anlamına gelir (lambda her çağrıda mutasyona uğramaktadır). Doğruluğu sağlamak için standart mutableanahtar kelimeyi tanıttı . Bir lambda'yı değiştirilebilir olarak belirterek, lambda'ya yapılan her çağrının lambda'nın kendisinde bir değişikliğe neden olabileceğini söylüyorsunuz. Başka bir örnek görelim:

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

}

Yukarıdaki örnek, lambda'yı değişken hale getirerek, lambda'nın xiçinde değiştirilmesinin , her çağrıda lambda'yı yeni bir değerle "değiştirdiğini" , ana işlevdeki xgerçek değerle ilgisi olmadığını xgöstermektedir.

Artık mutablelambda deklarasyonlarındaki ihtiyacı hafifletmek için bir teklif var : n3424

Yavru köpeğin cevabını genişletmek için lambda fonksiyonlarının saf fonksiyonlar olması amaçlanmıştır . Bu, benzersiz bir giriş seti verilen her çağrının daima aynı çıkışı döndürdüğü anlamına gelir. Girdiyi , lambda çağrıldığında tüm bağımsız değişkenlerin yanı sıra yakalanan tüm değişkenler kümesi olarak tanımlayalım .

Saf fonksiyonlarda çıkış, sadece bazı dahili durumlara değil, yalnızca girdilere bağlıdır. Bu nedenle, safsa herhangi bir lambda fonksiyonunun durumunu değiştirmesi gerekmez ve bu nedenle değişmezdir.

Bir lambda referans olarak yakalandığında, yakalanan değişkenler üzerine yazma saf fonksiyon kavramı üzerinde bir zorlamadır, çünkü saf bir fonksiyonun tek yapması gereken bir çıktı döndürmektir, ancak lambda mutasyona uğramaz çünkü yazma harici değişkenlere olur. Bu durumda bile doğru bir kullanım, lambda tekrar aynı girişle çağrılırsa, referansın değişkenleri üzerindeki bu yan etkilere rağmen, çıkışın her zaman aynı olacağı anlamına gelir. Bu tür yan etkiler sadece bazı ek girdileri (örneğin bir sayacı güncelleme) döndürmenin yoludur ve örneğin tek bir değer yerine bir demet döndürerek saf bir işleve dönüştürülebilir.