Perché il risultato di "decltype (i + j)" non è un riferimento di rvalue?

Question

Sto provando a trovare un semplice esempio per un'operazione che si traduce in un valore.

Questo test case avrebbe dovuto funzionare, ma sorprendentemente (per me), il risultato dell'aggiunta di due int s non è un valore di riferimento (riferimento). Cosa mi manca qui?

void test(int i, int j) 
{ 
    // this assert should pass, but fails: 
    static_assert(std::is_same<decltype(i + j), int&&>(), "i + j should be a rvalue"); 
    // this assert passed, but should fail: 
    static_assert(std::is_same<decltype(i + j), int>(), "this assert should fail..."); 
} 

Answer 1

i + j è un prvalue expression,

A prvalue ("pura rvalue") espressione è un'espressione che non ha identità e può essere spostato da.

a + b, a b%, un & b, a < < b, e tutte le altre espressioni aritmetiche built-in;

non xvalue,

Un xValue ("scadenza value") espressione è un'espressione che ha identità e può essere spostato da.

E decltype specifier cede T per prvalue, non T&&.

a) se la categoria valore di espressione è xValue, poi cede decltype T & &;
b) se la categoria di valore di espressione è lvalue, decltype restituisce T &;
c) se la categoria del valore di espressione è prvalue, quindi decltype cede T.

Si può rendere xValue da std::move:

static_assert(std::is_same<decltype(std::move(i + j)), int&&>(), "std::move(i + j) is a xvalue then this static_assert won't fail"); 

Answer 2

Sulla base di @Answer songyuanyao, ho notato che il mio errore Stavo controllando la cosa sbagliata: la mia intenzione era di verificare se il risultato di i+j fosse associare a un riferimento di rvalue, ma ho controllato se esso è un riferimento di rvalue.

decltype deduce il tipo basato sulla value category, non si basa su ciò che reference type il valore sarebbe legano a:

1) se la categoria del valore di espressione è xvalue, allora decltype rendimenti T&&;
2) se la categoria di valore di espressione è lvalue, quindi decltype produce T&;
3) se la categoria di valore di espressione è prvalue, quindi decltype produce T.

Come mostrato nella lista, dal C++ 11, rvalues non esistono come categoria distinta sul livello più basso. Ora sono una categoria composita che contiene sia prvalues sia xvalues. La domanda come scritta chiede se l'espressione è un rvalue reference e controlla se si tratta di un xvalue.

Dalla lista sopra, è chiaro che i+j è un prvalue, quindi si applica il terzo caso. Questo spiega perché decltype(i + j) è int e non int&&. Entrambi xvalues e prvaluessi legano a riferimenti di rvalue.

Così controllando se i+j si lega ad un lvalue reference o un rvalue reference conferma che, in effetti, lega a un rvalue reference:

void foo(const int& f) 
{ 
    std::cout << "binds to lvalue reference" << std::endl; 
} 

void foo(int&& f) 
{ 
    std::cout << "binds to rvalue reference" << std::endl; 
} 

void test(int i, int j) 
{ 
    foo(i); // lvalue -> lvalue ref 

    foo(std::move(i)); // xvalue -> rvalue ref 
    // (std::move converts the argument to a rvalue reference and returns it as an xvalue) 

    foo(i + j); // prvalue -> rvalue ref 
} 

In conclusione:i+j è non un riferimento rvalue , ma si lega a uno.