Por que não consigo capturar isso por referência ('e isso') em lambda?

Eu entendo que a maneira correta de capturar this(para modificar as propriedades do objeto) em um lambda é a seguinte:

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

Mas estou curioso para saber a seguinte peculiaridade que vi:

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;
};

A estranheza que me confunde (e gostaria de ser respondida) é por que o seguinte funciona:

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

E por que não consigo capturar explicitamente thispor referência:

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

O motivo pelo qual [&this]não funciona é porque é um erro de sintaxe. Cada parâmetro separado por vírgula no lambda-introduceré um capture:

capture:
    identifier
    & identifier
    this

Você pode ver que isso &thisnão é permitido sintaticamente. O motivo pelo qual não é permitido é porque você nunca deseja capturar thispor referência, pois é um pequeno ponteiro const. Você só gostaria de passá-lo por valor - então, a linguagem simplesmente não suporta a captura thispor referência.

Para capturar thisexplicitamente, você pode usar [this]como o lambda-introducer.

O primeiro capturepode ser um capture-defaultque é:

capture-default:
    &
    =

Isso significa capturar automaticamente tudo o que eu uso, por referência ( &) ou por valor ( =) respectivamente - no entanto, o tratamento de thisé especial - em ambos os casos é capturado por valor pelas razões dadas anteriormente (mesmo com uma captura padrão de &, o que geralmente significa captura por referência).

5.1.2.7/8:

Para fins de pesquisa de nome (3.4), determinar o tipo e valor de this(9.3.2) e transformar expressões id referentes a membros de classe não estáticos em expressões de acesso de membros de classe usando (*this)(9.3.1), a instrução composta [OF O LAMBDA] é considerado no contexto da expressão lambda.

Portanto, o lambda atua como se fosse parte da função de membro envolvente ao usar nomes de membro (como em seu exemplo o uso do nome x), então ele irá gerar "usos implícitos" thisexatamente como faz uma função de membro.

Se uma captura lambda inclui um padrão de captura, isto é &, os identificadores na captura lambda não devem ser precedidos por &. Se uma captura lambda inclui um padrão de captura, isto é =, a captura lambda não deve conter thise cada identificador que contém deve ser precedido por &. Um identificador ou thisnão deve aparecer mais de uma vez em uma captura lambda.

Assim você pode usar [this], [&], [=]ou [&,this]como um lambda-introducerpara capturar othis ponteiro por valor.

No entanto [&this]e [=, this]estão mal formados. No último caso, o gcc avisa com perdão sobre [=,this]isso explicit by-copy capture of ‘this’ redundant with by-copy capture defaultao invés de erros.

Porque o padrão não tem &this em 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. Para fins de captura lambda, uma expressão potencialmente faz referência a entidades locais da seguinte maneira:

   7.3 A esta expressão potencialmente faz referência a * this.

Portanto, o padrão garante thise *thisé válido e &thisé inválido. Além disso, capturar thissignifica capturar *this(que é um lvalue, o próprio objeto) por referência , em vez de capturar thisponteiro por valor !