Pourquoi le lambda de C ++ 11 nécessite-t-il, par défaut, un mot clé «mutable» pour la capture par valeur?

Petit exemple:

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

La question: pourquoi avons-nous besoin du mutablemot-clé? C'est assez différent du passage de paramètres traditionnel aux fonctions nommées. Quelle est la justification derrière?

J'avais l'impression que tout l'intérêt de la capture par valeur était de permettre à l'utilisateur de modifier le temporaire - sinon je ferais presque toujours mieux d'utiliser la capture par référence, n'est-ce pas?

Des éclaircissements?

(J'utilise MSVC2010 au fait. AFAIK cela devrait être standard)

Cela nécessite mutableparce que par défaut, un objet fonction doit produire le même résultat à chaque appel. C'est la différence entre une fonction orientée objet et une fonction utilisant une variable globale, effectivement.

Votre code est presque équivalent à ceci:

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

Vous pourriez donc penser à lambdas comme générant une classe avec operator () qui est par défaut const à moins que vous ne disiez qu'elle est mutable.

Vous pouvez également considérer toutes les variables capturées à l'intérieur de [] (explicitement ou implicitement) comme des membres de cette classe: des copies des objets pour [=] ou des références aux objets pour [&]. Ils sont initialisés lorsque vous déclarez votre lambda comme s'il y avait un constructeur caché.

J'avais l'impression que tout l'intérêt de la capture par valeur était de permettre à l'utilisateur de modifier le temporaire - sinon je ferais presque toujours mieux d'utiliser la capture par référence, n'est-ce pas?

La question est, est-ce "presque"? Un cas d'utilisation fréquent semble être de revenir ou de passer des lambdas:

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

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

Je pense que ce mutablen'est pas un cas de "presque". Je considère que "capture par valeur" comme "me permet d'utiliser sa valeur après la mort de l'entité capturée" plutôt que "me permet d'en changer une copie". Mais peut-être que cela peut être soutenu.

FWIW, Herb Sutter, membre bien connu du comité de normalisation C ++, fournit une réponse différente à cette question dans Lambda Correctness and Ergonomie Issues :

Prenons l'exemple de l'homme de paille, où le programmeur capture une variable locale par valeur et essaie de modifier la valeur capturée (qui est une variable membre de l'objet 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’

Cette fonctionnalité semble avoir été ajoutée par souci que l'utilisateur ne puisse pas réaliser qu'il a obtenu une copie, et en particulier parce que les lambdas sont copiables, il pourrait changer une copie de lambda différente.

Son article explique pourquoi cela devrait être changé en C ++ 14. Il est court, bien écrit et mérite d'être lu si vous voulez savoir «ce qui est à l'esprit [des membres du comité]» en ce qui concerne cette caractéristique particulière.

Vous devez réfléchir au type de fermeture de votre fonction Lambda. Chaque fois que vous déclarez une expression Lambda, le compilateur crée un type de fermeture, qui n'est rien de moins qu'une déclaration de classe sans nom avec des attributs ( environnement où l'expression Lambda a été déclarée) et l'appel de fonction ::operator()implémenté. Lorsque vous capturez une variable à l'aide de la copie par valeur , le compilateur crée un nouvel constattribut dans le type de fermeture, vous ne pouvez donc pas le modifier dans l'expression Lambda car il s'agit d'un attribut "en lecture seule", c'est la raison pour laquelle ils appelons cela une " fermeture ", car d'une certaine manière, vous fermez votre expression Lambda en copiant les variables de l'étendue supérieure dans l'étendue Lambda.mutable, l'entité capturée deviendra un non-constattribut de votre type de fermeture. C'est ce qui fait que les modifications apportées à la variable mutable capturée par valeur ne sont pas propagées à l'étendue supérieure, mais restent à l'intérieur du Lambda avec état. Essayez toujours d'imaginer le type de fermeture résultant de votre expression Lambda, qui m'a beaucoup aidé, et j'espère que cela peut vous aider aussi.

Voir ce projet , sous 5.1.2 [expr.prim.lambda], paragraphe 5:

Le type de fermeture d'une expression lambda a un opérateur d'appel de fonction en ligne public (13.5.4) dont les paramètres et le type de retour sont décrits respectivement par la clause de déclaration de paramètre et le type de retour de piste de l'expression lambda. Cet opérateur d'appel de fonction est déclaré const (9.3.1) si et seulement si la clause-déclaration-paramètre de lambdaexpression n'est pas suivie par mutable.

Modifier le commentaire de litb: Peut-être qu'ils ont pensé à la capture par valeur afin que les changements extérieurs aux variables ne soient pas reflétés à l'intérieur du lambda? Les références fonctionnent dans les deux sens, c'est donc mon explication. Je ne sais pas si c'est bon.

Edit sur le commentaire de kizzx2: La plupart du temps quand un lambda doit être utilisé est comme foncteur d'algorithmes. Le constness par défaut permet de l'utiliser dans un environnement constant, tout comme les constfonctions normales qualifiées peuvent y être utilisées, mais pas les fonctions non constqualifiées. Peut-être qu'ils ont juste pensé à le rendre plus intuitif pour ces cas, qui savent ce qui se passe dans leur esprit. :)

J'avais l'impression que tout l'intérêt de la capture par valeur était de permettre à l'utilisateur de modifier le temporaire - sinon je ferais presque toujours mieux d'utiliser la capture par référence, n'est-ce pas?

nn'est pas temporaire. n est membre de l'objet fonction-lambda que vous créez avec l'expression lambda. L'attente par défaut est que l'appel de votre lambda ne modifie pas son état, il est donc constant de vous empêcher de le modifier accidentellement n.

Vous devez comprendre ce que signifie la capture! c'est capturer et non passer l'argument! regardons quelques exemples de code:

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

}

Comme vous pouvez le voir, même s'il xa été modifié, 20le lambda renvoie toujours 10 ( xest toujours 5à l'intérieur du lambda) Changer xà l'intérieur du lambda signifie changer le lambda lui-même à chaque appel (le lambda mute à chaque appel). Pour appliquer l'exactitude, la norme a introduit le mutablemot - clé. En spécifiant un lambda comme mutable, vous dites que chaque appel au lambda pourrait provoquer un changement dans le lambda lui-même. Voyons un autre exemple:

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

}

L'exemple ci-dessus montre qu'en rendant le lambda mutable, changer xà l'intérieur du lambda "mute" le lambda à chaque appel avec une nouvelle valeur xqui n'a rien à voir avec la valeur réelle de xdans la fonction principale

Il existe maintenant une proposition pour alléger le besoin de mutabledéclarations in lambda: n3424

Pour étendre la réponse de Puppy, les fonctions lambda sont censées être des fonctions pures . Cela signifie que chaque appel donné un ensemble d'entrée unique renvoie toujours la même sortie. Définissons l' entrée comme l'ensemble de tous les arguments plus toutes les variables capturées lorsque le lambda est appelé.

Dans les fonctions pures, la sortie dépend uniquement de l'entrée et non d'un état interne. Par conséquent, toute fonction lambda, si elle est pure, n'a pas besoin de changer son état et est donc immuable.

Lorsqu'un lambda capture par référence, l'écriture sur les variables capturées met à rude épreuve le concept de fonction pure, car tout ce qu'une fonction pure devrait faire est de renvoyer une sortie, bien que le lambda ne mute certainement pas car l'écriture se produit sur des variables externes. Même dans ce cas, une utilisation correcte implique que si le lambda est appelé à nouveau avec la même entrée, la sortie sera la même à chaque fois, malgré ces effets secondaires sur les variables by-ref. Ces effets secondaires ne sont que des moyens de renvoyer des entrées supplémentaires (par exemple, mettre à jour un compteur) et pourraient être reformulés en une fonction pure, par exemple en renvoyant un tuple au lieu d'une seule valeur.