Perché specificare un riferimento lvalue per * questo su una funzione membro è diverso dal non specificare nulla?

Question

Considerate questo codice:

#include <iostream> 
using namespace std; 

struct A { 
    void f() { cout << "A::f" << endl; } 
    void f() const { cout << "A::f const" << endl; } 
}; 

struct B { 
    void f() & { cout << "B::f &" << endl; } 
    void f() const & { cout << "B::f const &" << endl; } 
}; 

A getA() { return A{}; } 
B getB() { return B{}; } 

int main() { 
    getA().f(); 
    getB().f(); 
} 

che stampa

A::f 
B::f const & 

Per B, viene selezionato il sovraccarico const, non quella non-const. Immagino che questo significhi che specificare un qualificatore di riferimento lvalue per * questo è diverso dal non specificare nulla. Perché? Il "implicito questo argomento" cambia tipo e il sovraccarico const diventa ora un candidato migliore nella risoluzione di sovraccarico?

Answer 1

In questo caso:

struct A { 
    void f() { cout << "A::f" << endl; } 
    void f() const { cout << "A::f const" << endl; } 
}; 

getA().f(); 

Entrambi i sovraccarichi sono vitali per f, ma quello non-const è preferito perché non richiede alcuna conversione.

Ma in questo caso:

struct B { 
    void f() & { cout << "B::f &" << endl; } 
    void f() const & { cout << "B::f const &" << endl; } 
}; 

getB().f(); 

Il primo overload richiede this di essere un lvalue. Ma in getB().f(), il risultato di getB() è un valore di prval, che non può essere associato a un valore non costante. Quindi questo sovraccarico non è fattibile e non selezionato.

Il secondo sovraccarico richiede tuttavia che this sia un valore const, a cui può associare un valore di prvalue: questo overload è fattibile e selezionato dal compilatore.

Answer 2

Per riferimento, la frase che totalmente fuorviato me è in [over.match.funcs], §13.3.1/4 di N3337:

4. Per le funzioni di membro non statici, il tipo del parametro oggetto implicito è

- “riferimento Ivalue a cv X” per funzioni dichiarate senza un ref-qualificazione o con il & ref-qualificazione

- “rvalue riferimento alla cv X” per le funzioni dichiarate con la & & ref-qualificazione

(sottolineatura mia).

Quindi stavo diventando un po 'pazzo sul perché c'era una differenza nell'output. Senza o con un qualificatore di riferimento & dovrebbe essere lo stesso secondo qui, giusto?

Beh, il motivo è una regola aggiuntiva nascosto in poi in §13.3.1/5

Per le funzioni di membro non statiche dichiarate senza un ref-qualificazione, una regola aggiuntiva si applica:

- anche se il parametro oggetto implicito non è const-qualificato, un valore rvalue può essere associato al parametro fintanto che in tutti gli altri aspetti l'argomento può essere convertito nel tipo del parametro oggetto implicito.

che innesca fondamentalmente la rvalue non-const alla conversione lvalue non const e rende la differenza nell'esempio di cui sopra. D'uh.