左值與右值

C++中左值與右值的概念是從C中繼承而來，一種簡單的定義是左值能夠出現(xiàn)再表達(dá)式的左邊或者右邊，而右值只能出現(xiàn)在表達(dá)式的右邊。

int a = 5; 	// a是左值，5是右值 
int b = a;	// b是左值，a也是左值
int c = a + b;	// c是左值，a + b是右值

另一種區(qū)分左值和右值的方法是：有名字、能取地址的值是左值，沒有名字、不能取地址的值是右值。比如上述語句中a，b, c是變量可以取地址，所以是左值，而5和a + b無法進行取地址操作，因此是右值。C++中左值與右值的一個主要的區(qū)別是：左值可以被修改，而右值不可修改。

左值引用與右值引用

了解了左值與右值的概念后，接下來介紹下C++中的左值引用與右值引用。左值引用很簡單，就是一個變量的別名，綁定到一個左值上：

int a = 1;
int& b = a; 	//a = 1,b = 1
b = 2;		// a = 2,b = 2

這里b就等于a，在匯編層面其實和普通的指針一樣，對引用的修改(b)也會修改到被引用的對象(a),需要注意的是，因為引用實際是一個別名，因此必須初始化，即告訴編譯器是那個具體對象的別名。因此下列左值引用都是錯誤的：

int& a;		// 錯誤！左值引用必須初始化
int& b = 10;	// 錯誤！左值引用不能以臨時變量初始化（臨時變量沒有地址）

右值引用是C++11中新增的特性，顧名思義，右值引用就是用來綁定到右值的引用，一個右值被綁定到右值引用之后，原本需要被銷毀的此右值生命周期會延長至綁定它的右值引用的生命周期。在匯編層面，右值引用和const引用所做的事情是一樣的，即產(chǎn)生臨時量來存儲常量。但是右值引用可以進行讀寫操作，而const引用只能進行讀操作。綁定右值引用使用&&，具體使用如下：

int a = 5;
int& b = a;		// 正確！b是一個左值引用
int&& c = 6;		// 正確！c是一個右值引用,綁定到右值6
int&& d = a * 2;	// 正確！d是一個右值引用，綁定到右值a * 2
int&& e = i;		// 錯誤！不能將左值綁定到右值引用
int& f = 7;		// 錯誤！不能將右值綁定到左值引用
const int& g = a * 3;	// 正確！可以將右值綁定到const 左值引用

可以看到我們雖然不能將右值綁定到左值引用，但是可以將右值綁定到const左值引用。
注意： 變量表達(dá)式都是左值！。變量可以看作是只有一個運算對象而沒有運算符的表達(dá)式，跟其他表達(dá)式一樣，變量表達(dá)式也有左值/右值屬性。變量表達(dá)式都是左值，因此我們不能將一個右值引用綁定到一個右值引用類型的變量上。

int&& a = 5;	// 正確！a是一個右值引用
int&& b = a;	// 錯誤！a是一個左值，不能綁定到右值引用

這里雖然a是右值引用類型，但是確實一個左值，因此無法綁定到右值引用b上。因為在C++中，右值一般是臨時對象，但是綁定到右值引用之后，其生命周期變長了，因此a是一個左值。我們不能將一個右值引用直接綁定到一個變量上，即使是這個變量是右值引用類型也不行。具體的這個問題在后續(xù)的介紹forward的時候會詳細(xì)說明。

左值/右值引用的模板實參推斷

在另一篇文章中介紹了C++的模板類型推斷的幾種類型,可以總結(jié)為以下三種：

1. ParamType 是一個指針或者引用（&），但是不是通用引用（&&）
2. ParamType是一個通用引用（&&）
3. ParamType既不是指針，也不是引用（&）或者通用引用（&&）

從左值引用函數(shù)參數(shù)推斷類型

當(dāng)一個函數(shù)參數(shù)是模板的左值引用（T&）時，根據(jù)綁定規(guī)則，只能傳遞一個左值實參，這個左值實參可以時const類型，也可以不是。如果實參時const的，那么T就會被推導(dǎo)為const類型

template<typename T>
void func(T& param);

int a = 0;
const int b = a;
func(a);	// T被推導(dǎo)為int,param類型為int&
func(b);	// T被推導(dǎo)為const int,param類型為const int&
func(5);	// 錯誤！實參必須是一個左值！

如果一個函數(shù)的類型時const T&，那么根據(jù)綁定規(guī)則，可以傳遞任何類型的實參:const或者非const，左值或者右值，由于函數(shù)類型本身已經(jīng)是const，因此T的推導(dǎo)結(jié)果不會是一個const，因為const已經(jīng)是函數(shù)參數(shù)類型的一部分了。

template<typename T>
void func(const T& param);

int a = 0;
const int b = a;
func(a);	// T被推導(dǎo)為int,param類型為const int&
func(b);	// T被推導(dǎo)為int,param類型為const int&
func(5);	// 正確！const T&可以綁定一個右值，T為int

可以看到，當(dāng)函數(shù)參數(shù)類型為const T&時，可以接受一個右值實參，而函數(shù)參數(shù)類型為 T& 時是不可以的。

從右值引用函數(shù)參數(shù)推斷類型

當(dāng)一個函數(shù)的參數(shù)是一個右值引用（T&&）時，根據(jù)綁定規(guī)則可以傳遞一個右值實參。類似左值引用推導(dǎo)，右值引用推導(dǎo)得到的T的類型為右值的類型：

template<typename T>
void func(T&& param);

func(5);	// 實參5為右值，T被推導(dǎo)為int類型

與不能給右值引用賦值左值不同，右值引用函數(shù)的模板實參卻可以接受一個左值的輸入。當(dāng)我們將一個左值傳遞給函數(shù)的右值引用參數(shù)時，且此右值引用指向模板參數(shù)類型（T&&）時，編譯器推導(dǎo)模板類型參數(shù)為實參的左值引用類型：

template<typename T>
void func(T&& param);

int a = 1;
func(a);	// T被推導(dǎo)為int&,而不是int

如上述推導(dǎo)所示，當(dāng)傳入一個左值a時，T被推導(dǎo)為int&,而不是int,對應(yīng)的param的類型為int& &&,根據(jù)引用折疊的規(guī)則，int& &&被折疊為int&。

引用折疊規(guī)則
T& & ，T& && 和T&& &都會被折疊為T&
T&& &&被折疊為T&&

引用折疊的規(guī)則告訴我們：如果一個函數(shù)的參數(shù)時指向模板參數(shù)類型的右值引用（如T&&）,則可以傳遞給它任意類型的實參，如果傳遞的左值實參，那么T將會推導(dǎo)成為一個左值引用，函數(shù)參數(shù)被實例化為一個普通的左值引用（T&）。這種引用叫做“通用引用”。

右值引用與通用引用

C++中T&&有兩種不同的意思，第一種是右值引用，用于綁定到右值上，它們主要存在的原因是為了聲明某個對象可以被移動。T&&的第二層意思是，它既可以是一個右值引用，也可以是一個左值引用。這種引用在代碼里看起來像是右值引用（T&&），又可以表現(xiàn)的像是左值引用（T&）。它既可以綁定到右值，也可以綁定到左值，還可以綁定到const和no_const對象上，幾乎可以綁定到任何東西，這種引用叫做“通用引用”。在兩種情況下會出現(xiàn)通用引用，最常見的就是函數(shù)模板參數(shù)：

template<typename T>
void func(T&& param); // param是一個通用引用

第二種情況是auto聲明符：

auto&& a = b;	//a是一個通用引用

以上兩種情況的共同之處在于都是類型推導(dǎo)。在func內(nèi)部，param類型需要被推導(dǎo)，在auto聲明中，a的類型也需要被推導(dǎo)，而如果帶有&&而不需要推導(dǎo)，則就是普通的右值引用：

void func(A&& param);	// 沒有類型推導(dǎo)，param是一個右值引用
A&& a = b;		// 沒有類型推導(dǎo)，a是一個右值引用

由于引用必須初始化，通用引用也一樣。一個通用引用的初始值決定了其具體代表的是一個左值引用還是右值引用。如果初始值是一個左值，那么通用引用對應(yīng)的就是左值引用，如果初始值是一個右值，那么通用引用對應(yīng)的就是一個右值引用。

template<typename T>
void func(T&& param); // param是一個通用引用

int a = 1;
func(a);		// a是左值，T被推導(dǎo)為int&,參數(shù)param的類型是int&,是一個左值引用
func(5);		// 5是右值,T被推導(dǎo)為int,參數(shù)param的類型是int&&,是一個右值引用

需要注意的是，判斷一個引用是不是通用引用，類型推導(dǎo)是必要的，但是并不是類型推導(dǎo)就是通用引用，還需要看是不是準(zhǔn)確的T&&，如：

template<typename T>
void func(std::vector<T>&& param); // param是一個右值引用

template<typename T>
void func(const T&& param); // param是一個右值引用

上述模板函數(shù)func被調(diào)用的時候，類型T也會被推導(dǎo)，但是參數(shù)param的類型并不是T&&，而是一個std::vector&&,因此param是一個右值引用而不是通用引用。即使多了一個const，那么param也不能成為一個通用引用。

理解std::move（）

有了上述的知識基礎(chǔ)之后，C++中的move函數(shù)功能就很好理解了，std::move的主要作用是將一個左值/右值無條件的轉(zhuǎn)換為右值，但是函數(shù)本身并不移動任何東西，只是進行類型的轉(zhuǎn)換，那么這種轉(zhuǎn)換是如何做到的呢？我們來看下std::move具體實現(xiàn)的代碼：

template<class T>
typename remove_reference<T>::type&& move(T&& param)
{
    using returnType = typename remove_reference<T>::type&&;
    return static_cast<returnType>(param);
}

通過源碼可以看到，std::move接受一個通用引用的參數(shù)，函數(shù)返回一個&&表明std::move函數(shù)返回的是一個右值引用，這里remove_reference表示移除類型T的引用部分，具體的實現(xiàn)可以參考文檔,即返回結(jié)果是右值。在C++14中std::move的實現(xiàn)更加簡單：

template<typename T>
decltype(auto) move(T&& param)
{
    using returnType = remove_reference_t<T>&&;
    return static_cast<returnType>(param);
}

讓我們通過以下的代碼示例具體分析下std::move是如何工作的：

string s1("hello"),s2;
s2 = std::move(string("world")); // 從右值移動數(shù)據(jù)
s2 = std::move(s1);		 // 將左值轉(zhuǎn)換為右值 

在第一個賦值中，傳遞給move的實參是一個右值，當(dāng)向一個右值引用傳遞一個右值時，推導(dǎo)的類型即被引用的類型，因此在std::move(string("world"))中：

• T被推導(dǎo)為string
• returnType為string
• move的返回類型為string&&
• move的函數(shù)參數(shù)param的類型為string&&
  則函數(shù)std::move被推導(dǎo)為：

string&& move(string&& param)
{
	return static_cast<string&&>(param);
}

由于param已經(jīng)時右值引用類型，因此實際上move函數(shù)什么也沒做。
在第二個賦值中，傳給std::move的參數(shù)是一個左值，則在std::move(s1)中：

• T被推導(dǎo)為string&
• returnType為string
• move的返回類型為string&&
• move的函數(shù)參數(shù)param的類型為string&
  則函數(shù)std::move被推導(dǎo)為：

string&& move(string& param)
{
	return static_cast<string&&>(param);
}

可以看到參數(shù)param被static_cast轉(zhuǎn)換為sting&&，在C++中，從一個左值static_cast到一個右值引用時允許的。
從以上的示例可以看到，不管傳入的是左值還是右值，最終move都會返回一個右值。

理解std::forward()

std::forward與std::move實現(xiàn)的功能是類似的，只不過std::move總是無條件的將它的參數(shù)轉(zhuǎn)換為右值，而std::forward只有在滿足一定的條件下才會執(zhí)行轉(zhuǎn)換。std::forward最常見的使用場景是一個模板函數(shù)，接受一個通用引用參數(shù)，并將其傳遞給另外的函數(shù)：

void Process(const A& lvalue);	// 處理左值
void Process(A&& rvalue);	// 處理右值

template<typename T>
void PrintAndProcess(T&& param)
{
    Print("Some Log");
    process(std::forward<T>(param))
}

現(xiàn)在考慮兩次對PrintAndProcess的調(diào)用，一次參數(shù)為左值，一次參數(shù)為右值

A a;
PrintAndProcess(a);		// 左值參數(shù)
PrintAndProcess(std::move(a));	// 右值參數(shù)

在PrintAndProcess函數(shù)內(nèi)部，參數(shù)param被傳遞給process函數(shù)，process函數(shù)分別對左值和右值進行了重載，傳入PrintAndProcess左值參數(shù)時希望process左值版本被調(diào)用，傳入PrintAndProcess右值參數(shù)時，process右值版本被調(diào)用。但是前面我們提過，一個右值引用的變量，其本身時一個左值，因此無論傳給PrintAndProcess函數(shù)的實參時左值還是右值，最終調(diào)用process函數(shù)都是左值版本。為了解決這個問題，我們就需要一種機制：當(dāng)傳入PrintAndProcess函數(shù)的實參是右值時，調(diào)用的時process的右值版本。這就是std::forward的使用場景：只把由右值初始化的參數(shù)，轉(zhuǎn)換為右值。

那么std::forward如何知道param參數(shù)是被一個左值還是一個右值給初始化的呢？我們來看下std::forward實現(xiàn)的源碼：

template<class T>
constexpr T&& forward(std::remove_reference_t<T>& arg) noexcept{
    // forward an lvalue as either an lvalue or an rvalue
    return (static_cast<T&&>(arg));
}

template<class T>
constexpr T&& forward(std::remove_reference_t<T>&& arg) noexcept{
    static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
        " substituting _Tp is an lvalue reference type");
    // forward an rvalue as an rvalue
    return (static_cast<T&&>(arg));
}

對于左值的轉(zhuǎn)發(fā)，首先通過獲取類型type，定義args為左值引用的左值變量，然后通過static_cast<T&&>進行強制轉(zhuǎn)換，這里T&&會發(fā)生引用折疊，當(dāng)T被推導(dǎo)為左值引用時，則為T&& &，折疊為T&,當(dāng)推導(dǎo)為右值引用時，則本身為T&&，forward返回值與static_cast都為T&&。
對于右值的轉(zhuǎn)發(fā)不同于左值，只有當(dāng)類型時右值時才進行static_cast轉(zhuǎn)換，arg為右值引用的左值變量，通過cast轉(zhuǎn)換為T&&。
對應(yīng)到上述PrintAndProcess函數(shù)中我們進行分析：文章來源地址http://www.zghlxwxcb.cn/news/detail-408752.html

• 當(dāng)PrintAndProcess(a)，傳入的為左值A(chǔ)時，T被推導(dǎo)為A&,std::forward返回值和static_cast被推導(dǎo)為A& &&，折疊為A&,返回一個左值。
• 當(dāng)PrintAndProcess(std::move(a))，傳入為右值時，T被推導(dǎo)為A,在std::forward返回值和static_cast被推導(dǎo)為T&&,返回一個右值。

std::move 和 std::forward對比

• std::move執(zhí)行到右值的無條件轉(zhuǎn)換。就其本身而言，它沒有move任何東西。
• std::forward只有在它的參數(shù)綁定到一個右值上的時候，它才轉(zhuǎn)換它的參數(shù)到一個右值。
• std::move和std::forward只不過就是執(zhí)行類型轉(zhuǎn)換的兩個函數(shù)；std::move沒有move任何東西，std::forward沒有轉(zhuǎn)發(fā)任何東西。在運行期，它們沒有做任何事情。它們沒有產(chǎn)生需要執(zhí)行的代碼，一個byte都沒有。
• std::forward()不僅可以保持左值或者右值不變，同時還可以保持const、Lreference、Rreference、validate等屬性不變；

到了這里，關(guān)于MordernC++之左值（引用）與右值（引用）的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！