Les Lambdas et la capture par référence les variables locales : Accès après la portée

Oui, cela provoque un comportement indéfini. Les lambdas référence de pile, les objets alloués qui sont allés hors de portée. (Techniquement, ce que je comprends, le comportement est défini jusqu'à ce que les lambdas accès a et/ou b. Si vous n'avez jamais invoquer le retour de l'lambdas alors il n'y a pas d'AC.)

C'est un comportement indéfini de la même façon que c'est un comportement indéfini pour renvoyer une référence à une pile alloué local et ensuite utiliser cette référence une fois que le local est hors de portée, sauf que dans ce cas, il est dissimulé un peu par le lambda.

En outre, notez que l'ordre dans lequel les lambdas sont invoqués n'est pas spécifié -- le compilateur est libre d'invoquer f.second() avant f.first() parce que les deux font partie de la même expression. Par conséquent, même si nous fixons le comportement non défini causés par l'utilisation de références à détruit des objets, à la fois 2 0 et 2 1 sont encore valide résultats de ce programme, et qui dépend de l'ordre dans lequel votre compilateur décide d'exécuter les lambdas. Notez que c'est pas un comportement indéfini, car le compilateur ne peut pas faire quoi que ce soit, plutôt il a simplement un peu de liberté pour décider de la ordre dans lequel faire quelques choses.

(Gardez à l'esprit que << dans votre main() fonction invoque une coutume operator<< fonction, et l'ordre dans lequel les arguments de la fonction sont évalués n'est pas spécifié. Les compilateurs sont libres d'émettre un code qui évalue tous les arguments de la fonction au sein de la même expression dans n'importe quel ordre, avec la contrainte que tous les arguments d'une fonction doit être évaluée avant que la fonction est appelée.)

Pour résoudre le premier problème, utilisez std::shared_ptr pour créer une référence compté objet. La Capture de ce pointeur partagé par valeur, et les lambdas gardera le-pointu pour objet vivant aussi longtemps qu'ils (et toutes les copies de celui-ci) existent. Cette allouées sur la pile d'objet est l'endroit où nous allons stocker l'état partagé de a et b.

Pour résoudre le deuxième problème, évaluer chaque lambda dans une déclaration séparée.

Voici votre code réécrit avec le comportement non défini fixe, et avec f.first() garanti d'être invoqués devant f.second():

std::pair<std::function<int()>, std::function<int()>> addSome() {
    //We store the "a" and "b" ints instead in a shared_ptr containing a pair.
    auto numbers = std::make_shared<std::pair<int, int>>(0, 0);

    //a becomes numbers->first
    //b becomes numbers->second

    //And we capture the shared_ptr by value.
    return std::make_pair(
        [numbers] {
            ++numbers->first;
            ++numbers->second;
            return numbers->first + numbers->second;
        },
        [numbers] {
            return numbers->first;
        }
    );
}

int main() {
    auto f = addSome();
    //We break apart the output into two statements to guarantee that f.first()
    //is evaluated prior to f.second().
    std::cout << f.first();
    std::cout << " " << f.second();
    return 0;
}

(Voir courir.)

OriginalL'auteur cdhowie

Quand vous allez hors de portée. Cela permettra de faire une copie de vos locaux.

void func(void)
{
    auto mylocal = getFromSomeWhere();
    doSearch([=] {
        mylocal->foudnSomthing();
    });
}

Lorsque vous êtes dans la portée , de mieux utiliser les références

MyType func(void)
{
    auto mylocal = getFromSomeWhere();
    return ([&] {
         return mylocal->doOperation();
    })
}

OriginalL'auteur user6787837