#include <type_traits>
int main() {
    // 正確，"01234" 類型為 const char [6]，因此是左值
    const char (&left)[6] = "01234";
    // 斷言正確，確實是 const char [6] 類型，注意 decltype(expr) 在 expr 是左值
    // 且非無括號包裹的 id 表達式與類成員表達式時，會返回左值引用
    static_assert(std::is_same<decltype("01234"), const char(&)[6]>::value, "");
    // 錯誤，"01234" 是左值，不可被右值引用
    // const char (&&right)[6] = "01234";
}

const char*   p   = "01234";  // 正確，"01234" 被隱式轉(zhuǎn)換為 const char*
const char*&& pr  = "01234";  // 正確，"01234" 被隱式轉(zhuǎn)換為 const char*，該轉(zhuǎn)換的結(jié)果是純右值
// const char*& pl = "01234"; // 錯誤，此處不存在 const char* 類型的左值
將亡值 (xvalue, expiring value)，是 C++11 為了引入右值引用而提出的概念（因此在傳統(tǒng) C++ 中， 純右值和右值是同一個概念），也就是即將被銷毀、卻能夠被移動的值。
將亡值可能稍有些難以理解，我們來看這樣的代碼：
std::vector<int> foo() {
    std::vector<int> temp = {1, 2, 3, 4};
    return temp;
}
std::vector<int> v = foo();

#include <iostream>
#include <string>
void reference(std::string& str) {
    std::cout << "左值" << std::endl;
}
void reference(std::string&& str) {
    std::cout << "右值" << std::endl;
}
int main()
{
    std::string lv1 = "string,"; // lv1 是一個左值
    // std::string&& r1 = lv1; // 非法, 右值引用不能引用左值
    std::string&& rv1 = std::move(lv1); // 合法, std::move可以將左值轉(zhuǎn)移為右值
    std::cout << rv1 << std::endl; // string,
    const std::string& lv2 = lv1 + lv1; // 合法, 常量左值引用能夠延長臨時變量的生命周期
    // lv2 += "Test"; // 非法, 常量引用無法被修改
    std::cout << lv2 << std::endl; // string,string,
    std::string&& rv2 = lv1 + lv2; // 合法, 右值引用延長臨時對象生命周期
    rv2 += "Test"; // 合法, 非常量引用能夠修改臨時變量
    std::cout << rv2 << std::endl; // string,string,string,Test
    reference(rv2); // 輸出左值
    return 0;
}

#include <iostream>
int main() {
    // int &a = std::move(1);    // 不合法，非常量左引用無法引用右值
    const int &b = std::move(1); // 合法, 常量左引用允許引用右值
    std::cout << a << b << std::endl;
}
第一個問題，為什么不允許非常量引用綁定到非左值？這是因為這種做法存在邏輯錯誤：
void increase(int & v) {
    v++;
}
void foo() {
    double s = 1;
    increase(s);
}

#include <iostream>
class A {
public:
    int *pointer;
    A():pointer(new int(1)) {
        std::cout << "構(gòu)造" << pointer << std::endl;
    }
    A(A& a):pointer(new int(*a.pointer)) {
        std::cout << "拷貝" << pointer << std::endl;
    } // 無意義的對象拷貝
    A(A&& a):pointer(a.pointer) {
        a.pointer = nullptr;
        std::cout << "移動" << pointer << std::endl;
    }
    ~A(){
        std::cout << "析構(gòu)" << pointer << std::endl;
        delete pointer;
    }
};
// 防止編譯器優(yōu)化
A return_rvalue(bool test) {
    A a,b;
    if(test) return a; // 等價于 static_cast<A&&>(a);
    else return b;     // 等價于 static_cast<A&&>(b);
}
int main() {
    A obj = return_rvalue(false);
    std::cout << "obj:" << std::endl;
    std::cout << obj.pointer << std::endl;
    std::cout << *obj.pointer << std::endl;
    return 0;
}

#include <iostream> // std::cout
#include <utility> // std::move
#include <vector> // std::vector
#include <string> // std::string
int main() {
    std::string str = "Hello world.";
    std::vector<std::string> v;
    // 將使用 push_back(const T&), 即產(chǎn)生拷貝行為
    v.push_back(str);
    // 將輸出 "str: Hello world."
    std::cout << "str: " << str << std::endl;
    // 將使用 push_back(const T&&), 不會出現(xiàn)拷貝行為
    // 而整個字符串會被移動到 vector 中，所以有時候 std::move 會用來減少拷貝出現(xiàn)的開銷
    // 這步操作后, str 中的值會變?yōu)榭?
    v.push_back(std::move(str));
    // 將輸出 "str: "
    std::cout << "str: " << str << std::endl;
    return 0;
}

void reference(int& v) {
    std::cout << "左值" << std::endl;
}
void reference(int&& v) {
    std::cout << "右值" << std::endl;
}
template <typename T>
void pass(T&& v) {
    std::cout << "普通傳參:";
    reference(v); // 始終調(diào)用 reference(int&)
}
int main() {
    std::cout << "傳遞右值:" << std::endl;
    pass(1); // 1是右值, 但輸出是左值
    std::cout << "傳遞左值:" << std::endl;
    int l = 1;
    pass(l); // l 是左值, 輸出左值
    return 0;
}

#include <iostream>
#include <utility>
void reference(int& v) {
    std::cout << "左值引用" << std::endl;
}
void reference(int&& v) {
    std::cout << "右值引用" << std::endl;
}
template <typename T>
void pass(T&& v) {
    std::cout << "              普通傳參: ";
    reference(v);
    std::cout << "       std::move 傳參: ";
    reference(std::move(v));
    std::cout << "    std::forward 傳參: ";
    reference(std::forward<T>(v));
    std::cout << "static_cast<T&&> 傳參: ";
    reference(static_cast<T&&>(v));
}
int main() {
    std::cout << "傳遞右值:" << std::endl;
    pass(1);
    std::cout << "傳遞左值:" << std::endl;
    int v = 1;
    pass(v);
    return 0;
}

template<typename _Tp>
constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{ return static_cast<_Tp&&>(__t); }
template<typename _Tp>
constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
    static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
        " substituting _Tp is an lvalue reference type");
    return static_cast<_Tp&&>(__t);
}