Cuando "esto" es capturado por una lambda, ¿tiene que usarse explícitamente?

Los ejemplos que he encontrado que capturan thisen una lambda lo usan explícitamente; p.ej:

capturecomplete = [this](){this->calstage1done();};

Pero parece que también es posible usarlo implícitamente; p.ej:

capturecomplete = [this](){calstage1done();};

Probé esto en g ++, y lo compilé.

¿Es este estándar C ++? (y si es así, qué versión), o es alguna forma de extensión?

c++ lambda this-pointer

— lavado
fuente

Las respuestas son correctas, pero hay una posible razón para usar this->explícitamente, que es garantizar que los valores capturados explícitamente se usen explícitamente. Tenga en cuenta que [](){ calstage1done(); }no sería legal, porque thisno sería capturado; pero cuando se captura thisde forma explícita, es sorprendente para el cuerpo de la función que aparece a simple vista no utilizar realmente el valor capturado: [this](){ calstage1done(); }.

— Kyle Strand

Puedo ver esto, pero al mismo tiempo parece horriblemente detallado para lo que debería ser una tarea simple.

— lavado el

Recuerdo MSVC (quizás sólo 2015) también tienen problemas con la captura thisy se utiliza en un lambda que también podría ser una razón para usarlo de manera explícita

— Flamefire

@plugwash: los desarrolladores tienden a ser siempre flojos y quieren minimizar las cosas, y los diseñadores de idiomas no son diferentes. Sin embargo, a menudo se requiere verbosidad para resolver la ambigüedad, y ese es el caso aquí.

— Flater

Respuestas:

Es estándar y ha sido así desde C ++ 11 cuando se agregaron lambdas. De acuerdo con cppreference.com :

Para fines de búsqueda de nombres, determinar el tipo y el valor del thispuntero y para acceder a miembros de clase no estáticos, el cuerpo del operador de llamada de función del tipo de cierre se considera en el contexto de la expresión lambda.

struct X {
    int x, y;
    int operator()(int);
    void f()
    {
        // the context of the following lambda is the member function X::f
        [=]()->int
        {
            return operator()(this->x + y); // X::operator()(this->x + (*this).y)
                                            // this has type X*
        };
    }
};

— Ayxan
fuente

Es completamente estándar y lo ha sido desde que las lambdas se introdujeron en C ++ 11.

No necesitas escribir this->allí.

— Carreras de ligereza en órbita
fuente