目標
以下代碼能否編譯通過，能否按照期望運行？
#include#includenamespace cpp98 { struct A { }; A func() { return A(); } int main() { int i = 1; i = 2; // 3 = 4; const int j = 5; // j = 6; i = j; func() = A(); return 0; } } namespace cpp11 { #define is_lvalue(x) std::is_lvalue_reference::value #define is_prvalue(x) !std::is_reference::value #define is_xvalue(x) std::is_rvalue_reference::value #define is_glvalue(x) (is_lvalue(x) || is_xvalue(x)) #define is_rvalue(x) (is_xvalue(x) || is_prvalue(x)) void func(); int non_reference(); int&& rvalue_reference(); std::pairmake(); struct Test { int field; void member_function() { static_assert(is_lvalue(field), ""); static_assert(is_prvalue(this), ""); } enum Enum { ENUMERATOR, }; }; int main() { int i; int&& j = std::move(i); Test test; static_assert(is_lvalue(i), ""); static_assert(is_lvalue(j), ""); static_assert(std::is_rvalue_reference::value, ""); static_assert(is_lvalue(func), ""); static_assert(is_lvalue(test.field), ""); static_assert(is_lvalue("hello"), ""); static_assert(is_prvalue(2), ""); static_assert(is_prvalue(non_reference()), ""); static_assert(is_prvalue(Test{3}), ""); static_assert(is_prvalue(test.ENUMERATOR), ""); static_assert(is_xvalue(rvalue_reference()), ""); static_assert(is_xvalue(make().first), ""); return 0; } } namespace reference { int&& rvalue_reference() { int local = 1; return std::move(local); } const int& const_lvalue_reference(const int& arg) { return arg; } int main() { auto&& i = rvalue_reference(); // dangling reference auto&& j = const_lvalue_reference(2); // dangling reference int k = 3; auto&& l = const_lvalue_reference(k); return 0; } } namespace auto_decl { int non_reference() { return 1; } int& lvalue_reference() { static int i; return i; } const int& const_lvalue_reference() { return lvalue_reference(); } int&& rvalue_reference() { static int i; return std::move(i); } int main() { auto [s1, s2] = std::pair(2, 3); auto&& t1 = s1; static_assert(!std::is_reference::value); static_assert(std::is_lvalue_reference::value); int i1 = 4; auto i2 = i1; decltype(auto) i3 = i1; decltype(auto) i4{i1}; decltype(auto) i5 = (i1); static_assert(!std::is_reference::value, ""); static_assert(!std::is_reference::value, ""); static_assert(!std::is_reference::value, ""); static_assert(std::is_lvalue_reference::value, ""); auto n1 = non_reference(); decltype(auto) n2 = non_reference(); auto&& n3 = non_reference(); static_assert(!std::is_reference::value, ""); static_assert(!std::is_reference::value, ""); static_assert(std::is_rvalue_reference::value, ""); auto l1 = lvalue_reference(); decltype(auto) l2 = lvalue_reference(); auto&& l3 = lvalue_reference(); static_assert(!std::is_reference::value, ""); static_assert(std::is_lvalue_reference::value, ""); static_assert(std::is_lvalue_reference::value, ""); auto c1 = const_lvalue_reference(); decltype(auto) c2 = const_lvalue_reference(); auto&& c3 = const_lvalue_reference(); static_assert(!std::is_reference::value, ""); static_assert(std::is_lvalue_reference::value, ""); static_assert(std::is_lvalue_reference::value, ""); auto r1 = rvalue_reference(); decltype(auto) r2 = rvalue_reference(); auto&& r3 = rvalue_reference(); static_assert(!std::is_reference::value, ""); static_assert(std::is_rvalue_reference::value, ""); static_assert(std::is_rvalue_reference::value, ""); return 0; } } namespace cpp17 { class NonMoveable { public: int i = 1; NonMoveable(int i) : i(i) { } NonMoveable(NonMoveable&&) = delete; }; NonMoveable make(int i) { return NonMoveable{i}; } void take(NonMoveable nm) { return static_cast(nm); } int main() { auto nm = make(2); auto nm2 = NonMoveable{make(3)}; // take(nm); take(make(4)); take(NonMoveable{make(5)}); return 0; } } int main() { cpp98::main(); cpp11::main(); reference::main(); auto_decl::main(); cpp17::main(); }
C++98表達式類別
每個C++表達式都有一個類型：42的類型為int，int i;則(i)的類型為int&。這些類型落入若干類別中。在C++98/03中，每個表達式都是左值或右值。
左值（lvalue）是指向真實儲存在內存或寄存器中的值的表達式。“l”指的是“left-hand side”，因為在C中只有lvalue才能寫在賦值運算符的左邊。相對地，右值（rvalue，“r”指的是“right-hand side”）只能出現在賦值運算符的右邊。
有一些例外，如const int i;，i雖然是左值但不能出現在賦值運算符的左邊。到了C++，類類型的rvalue卻可以出現在賦值運算符的左邊，事實上這裡的賦值是對賦值運算符函數的調用，與基本類型的賦值是不同的。
lvalue可以理解為可取地址的值，變量、對指針解引用、對返回類型為引用類型的函數的調用等，都是lvalue。臨時對象都是rvalue，包括字面量和返回類型為非引用類型的函數調用等。字符串字面量是個例外，它屬於不可修改的左值。
賦值運算符左邊需要一個lvalue，右邊需要一個rvalue，如果給它一個lvalue，該lvalue會被隱式轉換成rvalue。這個過程是理所當然的。
動機
C++11引入了右值引用和移動語義。函數返回的右值引用，顧名思義，應該表現得和右值一樣，但是這會破壞很多既有的規則：
rvalue是匿名的，不一定有存儲空間，但右值引用指向內存中的具體對象，該對象還要被維護著；
rvalue的類型是確定的，必須是完全類型，靜態類型與動態類型相同，而右值引用可以是不完全類型，也可以支持多態；
非類類型的rvalue沒有cv修飾（const和volatile），但右值引用可以有，而且修飾符必須保留。
這給傳統的lvalue/rvalue二分法帶來了挑戰，C++委員會面臨選擇：
維持右值引用是rvalue，添加一些特殊規則；
把右值引用歸為lvalue，添加一些特殊規則；
細化表達式類別。
上述問題只是冰山一角；歷史選擇了第三種方案。
C++11表達式類別
C++11提出了表達式類別（value category）的概念。雖然名叫“value category”，但類別劃分的是表達式而不是值，所以我從標題開始就把它譯為“表達式類別”。C++標準定義表達式為：
An expression is a sequence of operators and operands that specifies a computation. An expression can result in a value and can cause side effects.
每個表達式都是三種類別之一：左值（lvalue）、消亡值（xvalue）和純右值（prvalue），稱為主類別。還有兩種混合類別：lvalue和xvalue統稱範左值（glvalue），xvalue和prvalue統稱右值（rvalue）。
#define is_glvalue(x) (is_lvalue(x) || is_xvalue(x)) #define is_rvalue(x) (is_xvalue(x) || is_prvalue(x))
C++11對這些類別的定義如下：
lvalue指定一個函數或一個對象；
xvalue（eXpiring vavlue）也指向對象，通常接近其生命週期的終點；一些涉及右值引用的表達式的結果是xvalue；
gvalue（generalized lvalue）是一個lvalue或xvalue；
rvalue是xvalue、臨時對象或它們的子對象，或者沒有關聯對象的值；
prvalue（pure rvalue）是不是xvalue的rvalue。
這種定義不是很清晰。具體來講，lvalue包括：（點擊展開）
lvalue的性質：
與glvalue相同；
內置取地址運算符可以作用於lvalue；
可修改的lvalue可以出現在內置賦值運算符的左邊；
可以用來初始化一個左值引用。
prvalue包括：
prvalue的性質：
與rvalue相同；
不能是多態的；
非類類型且非數組的prvalue沒有cv修飾符，即使寫了也沒有；
必須是完全類型；
不能是抽象類型或其數組。
xvalue包括：
xvalue的性質；
與rvalue相同；
與glvalue相同。
glvalue的性質：
可以隱式轉換為prvalue；
可以是多態的；
可以是不完全類型。
rvalue的性質：
內置取地址運算符不能作用於rvalue；
不能出現在內置賦值或複合賦值運算符的左邊；
可以綁定給const左值引用（見下）；
可以用來初始化右值引用（見下）；
如果一個函數有右值引用參數和const左值引用參數兩個重載，傳入一個rvalue時，右值引用的那個重載被調用。
還有一些特殊的分類：
對於非靜態成員函數mf及其指針pmf，a.mf、p->mf、a.*pmf和p->*pmf都被歸類為prvalue，但它們不是常規的prvalue，而是pending（即將發生的） member function call，只能用於函數調用；
返回void的函數調用、向void的類型裝換和throw語句都是void表達式，不能用於初始化引用或函數參數；
C++中最小的尋址單位是字節，因此位域不能綁定到非const左值引用上；const左值引用和右值引用可以綁定位域，它們指向的是位域的一個拷貝。
終於把5個類別介紹完了。表達式可以分為lvalue、xvalue和prvalue三類，lvalue和prvalue與C++98中的lvalue和rvalue類似，而xvalue則完全是為右值引用而生，兼有glvalue與rvalue的性質。除了這種三分類法外，表達式還可以分為lvalue和rvalue兩類，它們之間的主要差別在於是否可以取地址；還可以分為glvalue和prvalue兩類，它們之間的主要差別在於是否存在實體，glvalue有實體，因而可以修改原對象，xvalue常被壓榨剩餘價值。
引用綁定
我們稍微岔開一會，來看兩個與表達式分類相關的特性。
引用綁定有以下類型：
左值引用綁定lvalue，cv修飾符只能多不能少；
右值引用可以綁定rvalue，我們通常不給右值引用加cv修飾符；
const左值引用可以綁定rvalue。
左值引用綁定lvalue天經地義，沒什麼需要關照的。但rvalue都是臨時對象，綁定給引用就意味著要繼續用它，它的生命週期會受到影響。通常，rvalue的生命週期會延長到綁定引用的聲明週期，但有以下例外：
由return語句返回的臨時對象在return語句結束後即銷燬，這樣的函數總是會返回一個空懸引用（dangling reference）；
綁定到初始化列表中的引用的臨時對象的生命週期只延長到構造函數結束――這是個缺陷，在C++14中被修復；
綁定到函數參數的臨時對象的生命週期延長到函數調用所在表達式結束，把該參數作為引用返回會得到空懸引用；
綁定到new表達式中的引用的臨時對象的生命週期只延長到包含new的表達式的結束，不會跟著那個對象。
簡而言之，臨時變量的生命週期只能延長一次。
#includeint&& rvalue_reference() { int local = 1; return std::move(local); } const int& const_lvalue_reference(const int& arg) { return arg; } int main() { auto&& i = rvalue_reference(); // dangling reference auto&& j = const_lvalue_reference(2); // dangling reference int k = 3; auto&& l = const_lvalue_reference(k); }
rvalue_reference返回一個指向局部變量的引用，因此i是空懸引用；2綁定到const_lvalue_reference的參數arg上，函數返回後延長的生命週期達到終點，因此j也是懸空引用；k在傳參的過程中根本沒有臨時對象創建出來，所以l不是空懸引用，它是指向k的const左值引用。
auto與decltype
從C++11開始，auto關鍵字用於自動推導類型，用的是模板參數推導的規則：如果是拷貝列表初始化，則對應模板參數為std::initializer_list
還好，這不是我們的重點。在引出重點之前，我們還得先看decltype。
decltype用於聲明一個類型（"declare type"），有兩種語法：
decltype(entity)；
decltype(expression)。
第一種，decltype的參數是沒有括號包裹的標識符或類成員，則decltype產生該實體的類型；如果是結構化綁定，則產生被引類型。
第二種，decltype的參數是不能匹配第一種的任何表達式，其類型為T，則根據其表達式類別討論：
如果是xvalue，產生T&&――#define is_xvalue(x) std::is_rvalue_reference
如果是lvalue，產生T&――#define is_lvalue(x) std::is_lvalue_reference
如果是prvalue，產生T――#define is_prvalue(x) !std::is_reference
因此，decltype(x)和decltype((x))產生的類型通常是不同的。
對於不帶引用修飾的auto，初始化器的表達式類別會被抹去，為此C++14引入了新語法decltype(auto)，產生的類型為decltype(expr)，其中expr為初始化器。對於局部變量，等號右邊加上一對圓括號，可以保留表達式類別。
#include#includeint non_reference() { return 1; } int& lvalue_reference() { static int i; return i; } const int& const_lvalue_reference() { return lvalue_reference(); } int&& rvalue_reference() { static int i; return std::move(i); } int main() { auto [s1, s2] = std::pair(2, 3); auto&& t1 = s1; static_assert(!std::is_reference::value); static_assert(std::is_lvalue_reference::value); int i1 = 4; auto i2 = i1; decltype(auto) i3 = i1; decltype(auto) i4{i1}; decltype(auto) i5 = (i1); static_assert(!std::is_reference::value); static_assert(!std::is_reference::value); static_assert(!std::is_reference::value); static_assert(std::is_lvalue_reference::value); auto n1 = non_reference(); decltype(auto) n2 = non_reference(); auto&& n3 = non_reference(); static_assert(!std::is_reference::value, ""); static_assert(!std::is_reference::value, ""); static_assert(std::is_rvalue_reference::value, ""); auto l1 = lvalue_reference(); decltype(auto) l2 = lvalue_reference(); auto&& l3 = lvalue_reference(); static_assert(!std::is_reference::value, ""); static_assert(std::is_lvalue_reference::value, ""); static_assert(std::is_lvalue_reference::value, ""); auto c1 = const_lvalue_reference(); decltype(auto) c2 = const_lvalue_reference(); auto&& c3 = const_lvalue_reference(); static_assert(!std::is_reference::value, ""); static_assert(std::is_lvalue_reference::value, ""); static_assert(std::is_lvalue_reference::value, ""); auto r1 = rvalue_reference(); decltype(auto) r2 = rvalue_reference(); auto&& r3 = rvalue_reference(); static_assert(!std::is_reference::value, ""); static_assert(std::is_rvalue_reference::value, ""); static_assert(std::is_rvalue_reference::value, ""); }
用auto定義的變量都是int類型，無論函數的返回類型的引用和const修飾；用decltype(auto)定義的變量的類型與函數返回類型相同；auto&&是轉發引用，n3類型為int&&，其餘與decltype(auto)相同。
C++17表達式類別
眾所周知，編譯器常會執行NRVO（named return value optimization），減少一次對函數返回值的移動或拷貝。不過，這屬於C++標準說編譯器可以做的行為，卻沒有保證編譯器會這麼做，因此客戶不能對此作出假設，從而需要提供一個拷貝或移動構造函數，儘管它們可能不會被調用。然而，並不是所有情況下都能提供移動構造函數，即使能移動構造函數也未必只是一個指針的交換。總之，我們明知移動構造函數不會被調用卻還要硬著頭皮提供一個，這樣做非常形式主義。
所以，C++17規定了拷貝省略，確保在以下情況下，即使拷貝或移動構造函數有可觀察的效果，它們也不會被調用，原本要拷貝或移動的對象直接在目標位置構造：
在return表達式中，運算數是忽略cv修飾符以後的返回類型的prvalue；
在初始化中，初始化器是與變量相同類型的prvalue。
值得一提的是，這類行為在C++17中不能算是一種優化，因為不存在用來拷貝或移動的臨時對象。事實上，C++17重新定義了表達式類別：
glvalue的求值能確定對象、位域、函數的身份；
prvalue的求值初始化對象或位域，或計算運算數的值，由上下文決定；
xvalue是表示一個對象或位域的資源能被重用的glvalue；
lvalue是不是xvalue的glvalue；
rvalue是prvalue或xvalue。
這個定義在功能上與C++11中的相同，但是更清晰地指出了glvalue和prvalue的區別――glvalue產生地址，prvalue執行初始化。
prvalue初始化的對象由上下文決定：在拷貝省略的情形下，prvalue不曾有關聯的對象；其他情形下，prvalue將產生一個臨時對象，這個過程稱為臨時實體化（temporary materialization）。
臨時實體化把一個完全類型的prvalue轉換成xvalue，在以下情形中發生：
把引用綁定到prvalue上；
類prvalue被獲取成員；
數組prvalue被轉換為指針或下標取元素；
prvalue出現在大括號初始化列表中，用於初始化一個std::initializer_list
被使用typeid或sizeof運算符；
在語句expr;中或被轉換成void，即該表達式的值被丟棄。
或者可以理解為，所有非拷貝省略的場合中的prvalue都會被臨時實體化。
class NonMoveable { public: int i = 1; NonMoveable(int i) : i(i) { } NonMoveable(NonMoveable&&) = delete; }; NonMoveable make(int i) { return NonMoveable{i}; } void take(NonMoveable nm) { return static_cast(nm); } int main() { auto nm = make(2); auto nm2 = NonMoveable{make(3)}; // take(nm); take(make(4)); take(NonMoveable{make(5)}); }
NonMoveable的移動構造函數被聲明為delete，於是拷貝構造函數也被隱式delete。在auto nm = make(2);中，NonMoveable{i}為prvalue，根據拷貝省略的第一條規則，它直接構造為返回值；返回值是NonMoveable的prvalue，與nm類型相同，根據第二條規則，這個prvalue直接在nm的位置上構造；兩部分結合，該聲明式相當於NonMoveable nm{2};。
在MSVC中，這段代碼不能通過編譯，這是編譯器未能嚴格遵守C++標準的緣故。然而，如果在NonMoveable的移動構造函數中添加輸出語句，程序運行起來也沒有任何輸出，即使在Debug模式下、即使用C++11標準編譯都如此。這也側面反映出拷貝省略的意義。
總結
C++11規定每個表達式都屬於lvalue、xvalue和prvalue三個類別之一，表達式另可分為lvalue和rvalue，或glvalue和prvalue。返回右值引用的函數調用是xvalue，右值引用類型的變量是lvalue。
const左值引用和右值引用可以綁定臨時對象，但是臨時對象的聲明週期只能延長一次，返回一個指向局部變量的右值引用也會導致空懸引用。
標識符加上一對圓括號成為表達式，decltype用於表達式可以根據其類別產生相應的類型，用decltype(auto)聲明變量可以保留表達式類別。
C++17中prvalue是否有關聯對象由上下文決定，拷貝省略規定了特定情況下對象不經拷貝或移動直接構造，NRVO成為強制性標準，使不能被移動的對象在語義上可以值傳遞。
參考
Value categories - cppreference.com
Value categories - [l, gl, x, r, pr]values
Value Categories in C++17
[lousu-xi ] C++98/11/17表達式類別(小結)已經有234次圍觀