understading questo invio esempio perfetto

Question

mi sono imbattuto nel seguente esempio durante il tentativo di capire cosa std::forward fa

// forward example 
#include <utility>  // std::forward 
#include <iostream>  // std::cout 

// function with lvalue and rvalue reference overloads: 
void overloaded (const int& x) {std::cout << "[lvalue]";} 
void overloaded (int&& x) {std::cout << "[rvalue]";} 

// function template taking rvalue reference to deduced type: 
template <class T> void fn (T&& x) { 
    overloaded (x);     // always an lvalue 
    overloaded (std::forward<T>(x)); // rvalue if argument is rvalue 
} 

int main() { 

    std::cout << "calling fn with rvalue: "; 
    fn (0); 
    std::cout << '\n'; 

    return 0; 
} 

L'output del programma è

chiamando Fn, insieme con rvalue: [lvalue] [rvalue ]

Ora la mia domanda è come abbiamo ricevuto lvalue prima? Ecco la mia linea di pensiero nel nostro main Ho chiamato fn(0); Ora 0 è valore. Quindi il riferimento x universale si deduce al seguente

void fn (int&& && x); 

Ora, secondo riferimento collasso che otterremmo

void fn (int&& x); 

rendendo così x comportarsi come un rvalue.So se x è passato poi rvalue metodo di overload dovrebbe essere chiamato. Tuttavia sembra che venga chiamata l'altra funzione di riferimento lvalue sovraccaricata. Sarei grato se qualcuno potesse chiarire questo

Answer 1

A denominata variabile non è MAI un valore. È invariabilmente un lvalue. I rvalori sono solo pure espressioni che non hanno nomi.

int && i = int(0); 

Qui l'espressione int(0) è un rvalue, ma la variabile i è di per sé un lvalue, dichiarato vincolante ad un rvalue.