Dlaczego domyślnie lambda C ++ 11 wymaga słowa kluczowego „mutable” do przechwytywania według wartości?

Krótki przykład:

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

Pytanie: Dlaczego potrzebujemy mutablesłowa kluczowego? Różni się to od tradycyjnego przekazywania parametrów do nazwanych funkcji. Jakie jest uzasadnienie?

Miałem wrażenie, że celem przechwytywania według wartości jest umożliwienie użytkownikowi zmiany ustawienia tymczasowego - w przeciwnym razie prawie zawsze lepiej jest używać przechwytywania przez odniesienie, prawda?

Jakieś oświecenia?

(Nawiasem mówiąc, używam MSVC2010. AFAIK to powinno być standardowe)

Wymaga to, mutableponieważ domyślnie obiekt funkcyjny powinien generować ten sam wynik przy każdym wywołaniu. Jest to różnica między funkcją zorientowaną obiektowo a funkcją efektywnie wykorzystującą zmienną globalną.

Twój kod jest prawie równoważny z tym:

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

Możesz więc pomyśleć o lambdach jako o generowaniu klasy z operatorem (), która domyślnie przyjmuje wartość const, chyba że powiesz, że jest zmienna.

Możesz również myśleć o wszystkich zmiennych przechwyconych wewnątrz [] (jawnie lub niejawnie) jako członkach tej klasy: kopie obiektów dla [=] lub odniesienia do obiektów dla [&]. Są inicjowane, kiedy deklarujesz swoją lambda, jakby istniał ukryty konstruktor.

Miałem wrażenie, że celem przechwytywania według wartości jest umożliwienie użytkownikowi zmiany ustawienia tymczasowego - w przeciwnym razie prawie zawsze lepiej jest używać przechwytywania przez odniesienie, prawda?

Pytanie brzmi, czy to „prawie”? Częstym przypadkiem użycia wydaje się być zwrot lub przekazanie lambdas:

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

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

Myślę, że mutableto nie jest przypadek „prawie”. Uważam, że „przechwytywanie według wartości” jak „pozwala mi używać jego wartości po śmierci przechwyconego bytu”, a nie „zezwalam na zmianę jego kopii”. Ale może to można argumentować.

FWIW, Herb Sutter, znany członek komitetu normalizacyjnego C ++, podaje inną odpowiedź na to pytanie w kwestiach poprawności i użyteczności lambda :

Rozważmy przykład słomianego człowieka, w którym programista przechwytuje zmienną lokalną według wartości i próbuje zmodyfikować przechwyconą wartość (która jest zmienną składową obiektu 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’

Wydaje się, że ta funkcja została dodana z obawy, że użytkownik może nie zdawać sobie sprawy, że dostał kopię, aw szczególności, że skoro lambd można kopiować, może zmieniać inną kopię lambdy.

Jego artykuł mówi o tym, dlaczego należy to zmienić w C ++ 14. Jest krótki, dobrze napisany, wart przeczytania, jeśli chcesz wiedzieć „co jest w umyśle [członka komitetu]” w odniesieniu do tej konkretnej funkcji.

Musisz pomyśleć, jaki jest typ zamknięcia twojej funkcji Lambda. Za każdym razem, gdy deklarujesz wyrażenie Lambda, kompilator tworzy typ zamknięcia, który jest niczym innym jak nienazwaną deklaracją klasy z atrybutami ( środowisko, w którym deklarowane jest wyrażenie Lambda) i ::operator()zaimplementowane wywołanie funkcji . Podczas przechwytywania zmiennej przy użyciu funkcji kopiowania według wartości kompilator utworzy nowy constatrybut w typie zamknięcia, więc nie można go zmienić w wyrażeniu Lambda, ponieważ jest to atrybut „tylko do odczytu”, dlatego nazwij to „ zamknięciem ”, ponieważ w pewien sposób zamykasz wyrażenie Lambda, kopiując zmienne z górnego zakresu do zakresu Lambda.mutable, przechwycona jednostka stanie się non-constatrybutem typu zamknięcia. To powoduje, że zmiany dokonane w zmiennej zmiennej przechwytywanej przez wartość nie są propagowane do górnego zakresu, ale pozostają w stanie Lambda. Zawsze próbuj sobie wyobrazić wynikowy typ zamknięcia twojego wyrażenia Lambda, który bardzo mi pomógł i mam nadzieję, że może ci również pomóc.

Zobacz ten projekt , pod 5.1.2 [expr.prim.lambda], podrozdział 5:

Typ zamknięcia dla wyrażenia lambda ma publiczny operator wywołania funkcji wbudowanej (13.5.4), którego parametry i typ zwracany są opisane odpowiednio przez klauzulę deklaracji parametru i typ wyrażenia lambda. Ten operator wywołania funkcji jest zadeklarowany jako const (9.3.1) wtedy i tylko wtedy, gdy po klauzuli deklaracji parametru lambdaexpression nie występuje zmienna.

Edytuj w komentarzu litba: Może pomyśleli o przechwytywaniu według wartości, aby zewnętrzne zmiany zmiennych nie były odzwierciedlone w lambda? Referencje działają w obie strony, więc to moje wyjaśnienie. Nie wiem, czy to jest dobre.

Edytuj w komentarzu kizzx2: Najczęściej kiedy lambda ma być używana, jest funktorem algorytmów. Domyślna constness pozwala na używanie jej w stałym środowisku, tak jak constmożna tam zastosować funkcje o normalnych kwalifikacjach, ale nie mogą to robić funkcje constniekwalifikowane. Może po prostu postanowili uczynić to bardziej intuicyjnym dla tych przypadków, którzy wiedzą, co dzieje się w ich umyśle. :)

Miałem wrażenie, że celem przechwytywania według wartości jest umożliwienie użytkownikowi zmiany ustawienia tymczasowego - w przeciwnym razie prawie zawsze lepiej jest używać przechwytywania przez odniesienie, prawda?

nto nie tymczasowy. n jest członkiem funkcji lambda utworzonej za pomocą wyrażenia lambda. Domyślnym oczekiwaniem jest to, że wywołanie lambda nie modyfikuje jej stanu, dlatego jest stałe, aby zapobiec przypadkowej modyfikacji n.

Musisz zrozumieć, co oznacza przechwytywanie! przechwytuje, a nie argumentuje! spójrzmy na kilka przykładów kodu:

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

}

Jak widać, mimo że xzmieniono 20na lambda, wciąż zwraca 10 ( xwciąż jest 5w lambdzie). Zmiana xw lambda oznacza zmianę samej lambdy przy każdym wywołaniu (lambda mutuje przy każdym wywołaniu). W celu wymuszenia poprawności standard wprowadził mutablesłowo kluczowe. Określając lambda jako zmienną, mówisz, że każde wywołanie lambda może spowodować zmianę w samej lambda. Zobaczmy inny przykład:

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

}

Powyższy przykład pokazuje, że poprzez zmodulowanie lambdy, zmiana xwewnątrz lambdy „mutuje” lambda przy każdym wywołaniu nową wartością x, która nie ma nic wspólnego z rzeczywistą wartością xfunkcji głównej

Obecnie istnieje propozycja zmniejszenia zapotrzebowania na mutabledeklaracje lambda: n3424

Aby rozszerzyć odpowiedź Puppy, funkcje lambda mają być funkcjami czystymi . Oznacza to, że każde wywołanie o unikalnym zestawie wejściowym zawsze zwraca ten sam wynik. Zdefiniujmy dane wejściowe jako zbiór wszystkich argumentów plus wszystkie przechwycone zmienne po wywołaniu lambda.

W funkcjach czystych wyjście zależy wyłącznie od danych wejściowych, a nie od stanu wewnętrznego. Dlatego każda funkcja lambda, jeśli jest czysta, nie musi zmieniać swojego stanu i dlatego jest niezmienna.

Kiedy lambda przechwytuje przez odniesienie, pisanie na przechwyconych zmiennych jest obciążeniem dla koncepcji czystej funkcji, ponieważ wszystko, co powinna zrobić czysta funkcja, to zwrócenie wyniku, chociaż lambda na pewno nie mutuje, ponieważ pisanie dzieje się ze zmiennymi zewnętrznymi. Nawet w tym przypadku poprawne użycie oznacza, że ​​jeśli lambda zostanie wywołana ponownie z tym samym wejściem, wynik będzie za każdym razem taki sam, pomimo tych skutków ubocznych zmiennych typu by-ref. Takie skutki uboczne to tylko sposoby na zwrócenie dodatkowych danych wejściowych (np. Aktualizacja licznika) i można je przeformułować na czystą funkcję, na przykład zwracając krotkę zamiast pojedynczej wartości.