Perché std :: forward restituisce static_cast <T&&> e non statico_cast <T>?

Question

Diamo una funzione chiamata Y che sovraccarica:

void Y(int& lvalue) 
{ cout << "lvalue!" << endl; } 

void Y(int&& rvalue) 
{ cout << "rvalue!" << endl; } 

Ora, definiamo una funzione template che si comporta come std :: avanti

template<class T> 
void f(T&& x) 
{ 
    Y(static_cast<T&&>(x)); // Using static_cast<T&&>(x) like in std::forward 
} 

Ora guardate la main()

int main() 
{ 
    int i = 10; 

    f(i);  // lvalue >> T = int& 
    f(10);  // rvalue >> T = int&& 
} 

Come previsto, l'output è

lvalue! 
rvalue! 

Ora tornare alla funzione modello f() e sostituire static_cast<T&&>(x) con static_cast<T>(x). Vediamo l'output:

lvalue! 
rvalue! 

È lo stesso! Perché? Se sono uguali, allora perché std::forward<> restituisce un cast da x a T&&?

Answer 1

La classificazione lvalue vs rvalue rimane la stessa, ma l'effetto è molto diverso (e la categoria di valore non cambia, anche se non in un modo osservabile nel tuo esempio). Andiamo oltre i quattro casi:

template<class T> 
void f(T&& x) 
{ 
    Y(static_cast<T&&>(x)); 
} 

template<class T> 
void g(T&& x) 
{ 
    Y(static_cast<T>(x)); 
} 

Se chiamiamo f con un lvalue, T sarà dedurre alcuni X&, quindi il riferimento getto crolla X& && ==> X&, così si finisce con lo stesso lvalue e non cambia nulla.

Se chiamiamo f con rvalue, T sarà dedurre alcuni X modo cast solo converte x ad un riferimento rvalue a x, quindi diventa un rvalue (specificamente, un xValue).

Se chiamiamo g con un lvalue, accadono sempre le stesse cose. Non è necessario alcun riferimento al collasso, dal momento che stiamo usando solo lo T == X&, ma il cast è ancora un no-op e alla fine continuiamo con lo stesso lvalue.

Ma se chiamiamo g con una rvalue, abbiamo static_cast<T>(x) che sarà copiarex. Quella copia è un valore di rvalue (come verifica il test - eccetto ora è un valore di valore invece di un valore x), ma è una copia extra e non necessaria al meglio e sarebbe un errore di compilazione (se T è mobile ma non copiabile) nel peggiore dei casi. Con static_cast<T&&>(x), abbiamo eseguito il casting su un riferimento, che non richiama una copia.

Ecco perché facciamo T&&.