¿Por qué no puedo capturar esto por referencia ('& this') en lambda?

Entiendo que la forma correcta de capturar this(modificar las propiedades del objeto) en una lambda es la siguiente:

auto f = [this] () { /* ... */ };

Pero tengo curiosidad por la siguiente peculiaridad que he visto:

class C {
    public:
        void foo() {
            // auto f = [] () { // this not captured
            auto f = [&] () { // why does this work?
            // auto f = [&this] () { // Expected ',' before 'this'
            // auto f = [this] () { // works as expected
                x = 5;
            };
            f();
        }

    private:
        int x;
};

La rareza que me confunde (y me gustaría recibir una respuesta) es por qué funciona lo siguiente:

auto f = [&] () { /* ... */ }; // capture everything by reference

Y por qué no puedo capturar explícitamente thispor referencia:

auto f = [&this] () { /* ... */ }; // a compiler error as seen above.

La razón [&this]no funciona es porque es un error de sintaxis. Cada parámetro separado por comas en el lambda-introduceres un capture:

capture:
    identifier
    & identifier
    this

Puede ver que eso &thisno está permitido sintácticamente. La razón por la que no está permitido es porque nunca querría capturar thispor referencia, ya que es un pequeño puntero constante. Solo querrá pasarlo por valor, por lo que el lenguaje simplemente no admite la captura thispor referencia.

Para capturar thisexplícitamente, puede usar [this]como lambda-introducer.

El primero capturepuede ser un capture-defaultque es:

capture-default:
    &
    =

Esto significa capturar automáticamente todo lo que uso, por referencia ( &) o por valor ( =) respectivamente, sin embargo, el tratamiento de thises especial, en ambos casos se captura por valor por las razones dadas anteriormente (incluso con una captura predeterminada de &, que generalmente significa capturar por referencia).

5.1.2.7/8:

Para propósitos de búsqueda de nombre (3.4), determinar el tipo y valor de this(9.3.2) y transformar expresiones id que se refieren a miembros de clase no estáticos en expresiones de acceso a miembros de clase usando (*this)(9.3.1), la declaración compuesta [OF THE LAMBDA] se considera en el contexto de la expresión lambda.

Entonces, lambda actúa como si fuera parte de la función miembro adjunta cuando se usan nombres de miembros (como en su ejemplo, el uso del nombre x), por lo que generará "usos implícitos" de la thismisma manera que lo hace una función miembro.

Si una captura lambda incluye una captura predeterminada &, es decir , los identificadores en la captura lambda no deben ir precedidos de &. Si una captura lambda incluye un valor predeterminado de captura =, es decir , la captura lambda no contendrá thisy cada identificador que contenga estará precedido por &. Un identificador o thisno aparecerá más de una vez en una captura lambda.

Así que usted puede utilizar [this], [&], [=]o [&,this]como lambda-introducerpara capturar el thispuntero por valor.

Sin embargo [&this]y [=, this]están mal formados. En el último caso, gcc advierte con perdón por [=,this]eso en explicit by-copy capture of ‘this’ redundant with by-copy capture defaultlugar de errores.

Porque estándar no tiene &thisen las listas de Capturas:

N4713 8.4.5.2 Capturas:

lambda-capture:
    capture-default
    capture-list
    capture-default, capture-list

capture-default:
    &
    =
capture-list:
    capture...opt
    capture-list, capture...opt
capture:
    simple-capture
    init-capture
simple-capture:
    identifier
    &identifier
    this
    * this
init-capture:
    identifier initializer
    &identifier initializer

7. A los efectos de la captura lambda, una expresión potencialmente hace referencia a entidades locales de la siguiente manera:

   7.3 A esta expresión potencialmente hace referencia a * esto.

Entonces, estándar garantiza thisy *thises válido y &thisno es válido. Además, capturar thissignifica capturar *this(que es un valor, el objeto en sí) por referencia , en lugar de capturar el thispuntero por valor .