Perché non riesco a catturare questo per riferimento ('& this') in lambda?

Capisco che il modo corretto per acquisire this(modificare le proprietà degli oggetti) in un lambda è il seguente:

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

Ma sono curioso della seguente particolarità che ho 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 stranezza da cui sono confuso (e vorrei una risposta) è il motivo per cui funziona:

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

E perché non posso acquisire in modo esplicito thisper riferimento:

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

Il motivo [&this]non funziona è perché si tratta di un errore di sintassi. Ogni parametro separato da virgole in lambda-introducerè un capture:

capture:
    identifier
    & identifier
    this

Puoi vedere che &thisnon è consentito sintatticamente. Il motivo per cui non è consentito è perché non vorresti mai acquisire thisper riferimento, poiché si tratta di un piccolo puntatore const. Vorresti solo passarlo per valore, quindi la lingua non supporta l'acquisizione thisper riferimento.

Per catturare in modo thisesplicito puoi usare [this]come file lambda-introducer.

Il primo capturepuò essere un capture-defaultche è:

capture-default:
    &
    =

Ciò significa catturare automaticamente tutto ciò che uso, rispettivamente per riferimento ( &) o per valore ( =) - tuttavia il trattamento di thisè speciale - in entrambi i casi viene catturato per valore per le ragioni fornite in precedenza (anche con un'acquisizione predefinita di &, che di solito significa cattura per riferimento).

5.1.2.7/8:

Ai fini della ricerca del nome (3.4), determinando il tipo e il valore di this(9.3.2) e trasformando espressioni id che si riferiscono a membri di classi non statiche in espressioni di accesso ai membri di classe usando (*this)(9.3.1), l'istruzione composta [OF THE LAMBDA] è considerato nel contesto dell'espressione lambda.

Quindi il lambda si comporta come se fosse parte della funzione membro che lo racchiude quando si usano i nomi dei membri (come nel tuo esempio l'uso del nome x), quindi genererà "usi impliciti" thisproprio come fa una funzione membro.

Se un'acquisizione lambda include un'acquisizione predefinita &, gli identificatori nell'acquisizione lambda non devono essere preceduti da &. Se un'acquisizione lambda include un'acquisizione predefinita, ovvero =l'acquisizione lambda non deve contenere this e ogni identificatore che contiene deve essere preceduto da &. Un identificatore o thisnon deve apparire più di una volta in una cattura lambda.

Così si può utilizzare [this], [&],[=] o [&,this]come lambda-introducerper catturare il thispuntatore per valore.

Tuttavia [&this]e [=, this]sono mal formati. In quest'ultimo caso gcc avverte forgivingly per [=,this]che explicit by-copy capture of ‘this’ redundant with by-copy capture default, piuttosto che errori.

Perché lo standard non ha &thisnegli elenchi di Catture:

N4713 8.4.5.2 Catture:

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. Ai fini dell'acquisizione lambda, un'espressione fa potenzialmente riferimento a entità locali come segue:

   7.3 Questa espressione fa potenzialmente riferimento * a questo.

Quindi, lo standard garantisce thised *thisè valido e &thisnon è valido. Inoltre, catturare thissignifica catturare *this(che è un lvalue, l'oggetto stesso) per riferimento , piuttosto che catturare il thispuntatore per valore !