Чому лямбда C ++ 11 за замовчуванням вимагає "змінне" ключове слово для отримання даних за значенням?

Короткий приклад:

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

Питання: Для чого нам потрібне mutableключове слово? Він зовсім відрізняється від традиційного переходу параметра до названих функцій. Що за обґрунтування?

У мене склалося враження, що вся суть захоплення за значенням полягає в тому, щоб дозволити користувачеві змінити тимчасову - інакше мені майже завжди краще використовувати захоплення за посиланням, чи не так?

Будь-які просвіти?

(Я, до речі, використовую MSVC2010. AFAIK це має бути стандартним)

Це потрібно, mutableтому що за замовчуванням функціональний об'єкт повинен створювати однаковий результат кожного разу, коли він викликається. Це різниця між об'єктно-орієнтованою функцією та функцією, що ефективно використовує глобальну змінну.

Ваш код майже еквівалентний цьому:

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

Таким чином, ви можете подумати про лямбда як про генерування класу з оператором (), який за замовчуванням const, якщо ви не скажете, що він є змінним.

Ви також можете вважати всі змінні, захоплені всередині [] (явно або неявно) як члени цього класу: копії об'єктів для [=] або посилання на об'єкти для [&]. Вони ініціалізуються, коли ви оголошуєте свою лямбда як би прихований конструктор.

У мене склалося враження, що вся суть захоплення за значенням полягає в тому, щоб дозволити користувачеві змінити тимчасову - інакше мені майже завжди краще використовувати захоплення за посиланням, чи не так?

Питання в тому, це "майже"? Частим випадком використання є повернення або передача лямбдів:

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

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

Я думаю, що mutableце не «майже». Я вважаю, що "захоплення за значенням" на зразок "дозволити мені використовувати його значення після вмирання захопленого об'єкта", а не "дозволити мені змінити його копію". Але, можливо, це можна стверджувати.

FWIW, Herb Sutter, відомий член комітету зі стандартизації C ++, надає іншу відповідь на це питання в питаннях коректності та зручності використання 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’

Здається, ця функція була додана з побоювання, що користувач може не усвідомлювати, що він отримав копію, і, особливо, оскільки, оскільки лямбда-файли копіюються, він може змінити іншу лямбда-копію.

Його праця розповідає про те, чому це слід змінити в C ++ 14. Це коротке, добре написане, яке варто прочитати, якщо ви хочете дізнатися про те, що у голові [члена комітету] щодо цієї особливості.

Вам потрібно подумати, який тип закриття вашої функції лямбда. Кожного разу, коли ви заявляєте вираз Lambda, компілятор створює тип закриття, який є не менш ніж оголошення без назви класу з атрибутами ( середовище, де вираз Lambda, де оголошено) та ::operator()реалізований виклик функції . Коли ви захоплюєте змінну за допомогою копіювання за значенням , компілятор створить новий constатрибут типу закриття, тому ви не можете змінити його всередині виразу Lambda, оскільки це атрибут "тільки для читання", тому вони називаємо це " закриттям ", тому що якимось чином ви закриваєте свій вираз Lambda, копіюючи змінні з верхньої області в область Lambda.mutable, захоплена сутність стане non-constатрибутом вашого типу закриття. Саме це призводить до того, що зміни, внесені у змінну змінну, захоплену за значенням, не поширюються на верхній обсяг, а зберігають всередині стані Лямбда. Завжди намагайтеся уявити отриманий тип закриття вашого лямбдаського виразу, який мені дуже допоміг, і я сподіваюся, що він теж може вам допомогти.

Дивіться цей проект під п. 5.1.2 [expr.prim.lambda], підпункт 5:

Тип закриття лямбда-виразу має оператор виклику функцій загального вбудованого функціонування (13.5.4), параметри та тип повернення описуються відповідно параметром декларування-лямбда-виразу та заднім типом повернення. Оператор виклику цієї функції оголошується const (9.3.1) тоді і лише тоді, коли параметр-декларація параметра лямбдаекспресії не супроводжується зміною.

Редагувати в коментарі litb: Можливо, вони подумали про захоплення за вартістю, щоб зовнішні зміни змінних не відображалися всередині лямбда? Посилання працюють обома способами, тому це моє пояснення. Не знаю, чи добре це все-таки.

Редагувати в коментарі kizzx2: Найчастіше, коли лямбда використовується, є функцією для алгоритмів. constНісс за замовчуванням дозволяє використовувати його в постійному середовищі, як звичайнеconstНісс там можна використовувати кваліфіковані функції, але constнекваліфіковані не можуть. Можливо, вони просто думали зробити це більш інтуїтивним для тих випадків, які знають, що відбувається в їхній свідомості. :)

У мене склалося враження, що вся суть захоплення за значенням полягає в тому, щоб дозволити користувачеві змінити тимчасову - інакше мені майже завжди краще використовувати захоплення за посиланням, чи не так?

nце НЕ тимчасове. n - член об’єкта лямбда-функції, який ви створюєте за допомогою виразу лямбда. За замовчуванням очікується, що виклик вашої лямбда не змінює її стан, тому просто запобігти випадковому зміні n.

Ви повинні зрозуміти, що означає захоплення! це захоплення не аргумент передачі! давайте розглянемо кілька зразків коду:

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

}

Як ви бачите, навіть якщо xзмінено на 20лямбда, все ще повертається 10 ( xвсе ще знаходиться 5всередині лямбда). Зміна xвсередині лямбда означає зміну самої лямбда при кожному дзвінку (лямбда мутує при кожному дзвінку). Для забезпечення правильності стандарт ввів mutableключове слово. Вказуючи лямбду як змінну, ви говорите, що кожен виклик лямбда може викликати зміну самого лямбда. Подивіться інший приклад:

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

}

Наведений вище приклад показує, що, роблячи лямбда-змінним, зміна xвсередині лямбда "мутує" лямбда при кожному виклику з новим значенням, xяке не має нічого спільного з фактичним значенням xосновної функції

Зараз є пропозиція полегшити потребу mutableв лямбда-деклараціях: n3424

Щоб розширити відповідь Щеня, лямбда-функції призначені як чисті функції . Це означає, що кожен виклик, отриманий унікальним набором вводу, завжди повертає один і той же вихід. Давайте визначимо вхід як набір усіх аргументів плюс усі захоплені змінні, коли лямбда викликається.

У чистих функціях вихід залежить виключно від введення, а не від якогось внутрішнього стану. Тому будь-яка лямбда-функція, якщо вона чиста, не потребує зміни свого стану і тому є незмінна.

Коли лямбда захоплює посиланням, запис на захоплених змінних є напругою щодо концепції чистої функції, тому що вся чиста функція повинна робити, це повернути вихід, хоча лямбда не мусить, безумовно, мутувати, оскільки запис відбувається із зовнішніми змінними. Навіть у цьому випадку правильне використання означає, що якщо лямбда викликається знову з одним і тим же входом, вихід буде кожного разу однаковим, незважаючи на ці побічні ефекти на змінних, що перераховуються. Такі побічні ефекти є лише способами повернути деякий додатковий вклад (наприклад, оновити лічильник) і можуть бути переформульовані в чисту функцію, наприклад, повернення кортежу замість одного значення.