右值引用

為了解決移動(dòng)語(yǔ)義及完美轉(zhuǎn)發(fā)問(wèn)題，C++11標(biāo)準(zhǔn)引入了右值引用（rvalue reference）這一重要的新概念。右值引用采用T&&這一語(yǔ)法形式，比傳統(tǒng)的引用T&（如今被稱作左值引用 lvalue reference）多一個(gè)&。

如果把經(jīng)由T&&這一語(yǔ)法形式所產(chǎn)生的引用類型都叫做右值引用，那么這種廣義的右值引用又可分為以下三種類型：

• 無(wú)名右值引用
• 具名右值引用
• 轉(zhuǎn)發(fā)型引用

無(wú)名右值引用和具名右值引用的引入主要是為了解決移動(dòng)語(yǔ)義問(wèn)題。

轉(zhuǎn)發(fā)型引用的引入主要是為了解決完美轉(zhuǎn)發(fā)問(wèn)題。 

無(wú)名右值引用

無(wú)名右值引用（unnamed rvalue reference）是指由右值引用相關(guān)操作所產(chǎn)生的引用類型。

無(wú)名右值引用主要通過(guò)返回右值引用的類型轉(zhuǎn)換操作產(chǎn)生， 其語(yǔ)法形式如下：

static_cast<T&&>(t)

標(biāo)準(zhǔn)規(guī)定該語(yǔ)法形式將把表達(dá)式 t 轉(zhuǎn)換為T(mén)類型的無(wú)名右值引用。

無(wú)名右值引用是右值，標(biāo)準(zhǔn)規(guī)定無(wú)名右值引用和傳統(tǒng)的右值一樣具有潛在的可移動(dòng)性，即它所占有的資源可以被移動(dòng)（竊?。?nbsp;

std::move()

由于無(wú)名右值引用是右值，借助于類型轉(zhuǎn)換操作產(chǎn)生無(wú)名右值引用這一手段，左值表達(dá)式就可以被轉(zhuǎn)換成右值表達(dá)式。為了便于利用這一重要的轉(zhuǎn)換操作，標(biāo)準(zhǔn)庫(kù)為我們提供了封裝這一操作的函數(shù)，這就是std::move()。

假設(shè)左值表達(dá)式 t 的類型為T(mén)&，利用以下函數(shù)調(diào)用就可以把左值表達(dá)式 t 轉(zhuǎn)換為T(mén)類型的無(wú)名右值引用（右值，類型為T(mén)&&）。
std::move(t)

具名右值引用

如果某個(gè)變量或參數(shù)被聲明為T(mén)&&類型，并且T無(wú)需推導(dǎo)即可確定，那么這個(gè)變量或參數(shù)就是一個(gè)具名右值引用（named rvalue reference）。

具名右值引用是左值，因?yàn)榫呙抑狄糜忻?，和傳統(tǒng)的左值引用一樣可以用操作符&取地址。

與廣義的右值引用相對(duì)應(yīng)，狹義的右值引用僅限指具名右值引用。

傳統(tǒng)的左值引用可以綁定左值，在某些情況下也可綁定右值。與此不同的是，右值引用只能綁定右值。

右值引用和左值引用統(tǒng)稱為引用（reference），它們具有引用的共性，比如都必須在初始化時(shí)綁定值，都是左值等等。

struct X {}; 
X a; 
X&& b = static_cast<X&&>(a); 
X&& c = std::move(a); 
//static_cast<X&&>(a) 和 std::move(a) 是無(wú)名右值引用，是右值 
//b 和 c 是具名右值引用，是左值 
X& d = a; 
X& e = b; 
const X& f = c; 
const X& g = X(); 
X&& h = X(); 
//左值引用d和e只能綁定左值（包括傳統(tǒng)左值：變量a以及新型左值：右值引用b） 
//const左值引用f和g可以綁定左值（右值引用c），也可以綁定右值（臨時(shí)對(duì)象X()） 
//右值引用b，c和h只能綁定右值（包括新型右值：無(wú)名右值引用std::move(a)以及傳統(tǒng)右值：臨時(shí)對(duì)象X()） 

左右值重載策略

有時(shí)我們需要在函數(shù)中區(qū)分參數(shù)的左右值屬性，根據(jù)參數(shù)左右值屬性的不同做出不同的處理。適當(dāng)?shù)夭捎米笥抑抵剌d策略，借助于左右值引用參數(shù)不同的綁定特性，我們可以利用函數(shù)重載來(lái)做到這一點(diǎn)。常見(jiàn)的左右值重載策略如下：

struct X {}; 
//左值版本 
void f(const X& param1){/*處理左值參數(shù)param1*/} 
//右值版本 
void f(X&& param2){/*處理右值參數(shù)param2*/} 
X a; 
f(a);      //調(diào)用左值版本 
f(X());     //調(diào)用右值版本 
f(std::move(a)); //調(diào)用右值版本 

即在函數(shù)重載中分別重載const左值引用和右值引用。

重載const左值引用的為左值版本，這是因?yàn)閏onst左值引用參數(shù)能綁定左值，而右值引用參數(shù)不能綁定左值。

重載右值引用的為右值版本，這是因?yàn)殡m然const左值引用參數(shù)和右值引用參數(shù)都能綁定右值，但標(biāo)準(zhǔn)規(guī)定右值引用參數(shù)的綁定優(yōu)先度要高于const左值引用參數(shù)。

移動(dòng)構(gòu)造器和移動(dòng)賦值運(yùn)算符

在類的構(gòu)造器和賦值運(yùn)算符中運(yùn)用上述左右值重載策略，就會(huì)產(chǎn)生兩個(gè)新的特殊成員函數(shù)：移動(dòng)構(gòu)造器（move constructor）和移動(dòng)賦值運(yùn)算符（move assignment operator）。

struct X 
{ 
  X();             //缺省構(gòu)造器 
  X(const X& that);      //拷貝構(gòu)造器 
  X(X&& that);         //移動(dòng)構(gòu)造器 
  X& operator=(const X& that); //拷貝賦值運(yùn)算符 
  X& operator=(X&& that);   //移動(dòng)賦值運(yùn)算符 
}; 
X a;               //調(diào)用缺省構(gòu)造器 
X b = a;             //調(diào)用拷貝構(gòu)造器 
X c = std::move(b);       //調(diào)用移動(dòng)構(gòu)造器 
b = a;              //調(diào)用拷貝賦值運(yùn)算符 
c = std::move(b);        //調(diào)用移動(dòng)賦值運(yùn)算符 

移動(dòng)語(yǔ)義

無(wú)名右值引用和具名右值引用的引入主要是為了解決移動(dòng)語(yǔ)義問(wèn)題。

移動(dòng)語(yǔ)義問(wèn)題是指在某些特定情況下（比如用右值來(lái)賦值或構(gòu)造對(duì)象時(shí)）如何采用廉價(jià)的移動(dòng)語(yǔ)義替換昂貴的拷貝語(yǔ)義的問(wèn)題。

移動(dòng)語(yǔ)義（move semantics）是指某個(gè)對(duì)象接管另一個(gè)對(duì)象所擁有的外部資源的所有權(quán)。移動(dòng)語(yǔ)義需要通過(guò)移動(dòng)（竊?。┢渌?/p>

對(duì)象所擁有的資源來(lái)完成。移動(dòng)語(yǔ)義的具體實(shí)現(xiàn)（即一次that對(duì)象到this對(duì)象的移動(dòng)（move））通常包含以下若干步驟：

• 如果this對(duì)象自身也擁有資源，釋放該資源
• 將this對(duì)象的指針或句柄指向that對(duì)象所擁有的資源
• 將that對(duì)象原本指向該資源的指針或句柄設(shè)為空值

上述步驟可簡(jiǎn)單概括為①釋放this（this非空時(shí)）②移動(dòng)that

移動(dòng)語(yǔ)義通常在移動(dòng)構(gòu)造器和移動(dòng)賦值運(yùn)算符中得以具體實(shí)現(xiàn)。兩者的區(qū)別在于移動(dòng)構(gòu)造對(duì)象時(shí)this對(duì)象為空因而①釋放this無(wú)須進(jìn)行。

與移動(dòng)語(yǔ)義相對(duì)，傳統(tǒng)的拷貝語(yǔ)義（copy semantics）是指某個(gè)對(duì)象拷貝（復(fù)制）另一個(gè)對(duì)象所擁有的外部資源并獲得新生資源的所有權(quán)?？截愓Z(yǔ)義的具體實(shí)現(xiàn)（即一次that對(duì)象到this對(duì)象的拷貝（copy））通常包含以下若干步驟：

• 如果this對(duì)象自身也擁有資源，釋放該資源
• 拷貝（復(fù)制）that對(duì)象所擁有的資源
• 將this對(duì)象的指針或句柄指向新生的資源
• 如果that對(duì)象為臨時(shí)對(duì)象（右值），那么拷貝完成之后that對(duì)象所擁有的資源將會(huì)因that對(duì)象被銷毀而即刻得以釋放
  

上述步驟可簡(jiǎn)單概括為①釋放this（this非空時(shí)）②拷貝that③釋放that（that為右值時(shí)）
拷貝語(yǔ)義通常在拷貝構(gòu)造器和拷貝賦值運(yùn)算符中得以具體實(shí)現(xiàn)。兩者的區(qū)別在于拷貝構(gòu)造對(duì)象時(shí)this對(duì)象為空因而①釋放this無(wú)須進(jìn)行。

比較移動(dòng)語(yǔ)義與拷貝語(yǔ)義的具體步驟可知，在賦值或構(gòu)造對(duì)象時(shí)，

如果源對(duì)象that為左值，由于兩者效果不同（移動(dòng)that ≠ 拷貝that），此時(shí)移動(dòng)語(yǔ)義不能用來(lái)替換拷貝語(yǔ)義。

如果源對(duì)象that為右值，由于兩者效果相同（移動(dòng)that ＝ 拷貝that ＋ 釋放that），此時(shí)廉價(jià)的移動(dòng)語(yǔ)義（通過(guò)指針操作來(lái)移動(dòng)資源）便可以用來(lái)替換昂貴的拷貝語(yǔ)義（生成，拷貝然后釋放資源）。

由此可知，只要在進(jìn)行相關(guān)操作（比如賦值或構(gòu)造）時(shí)，采取適當(dāng)?shù)淖笥抑抵剌d策略區(qū)分源對(duì)象的左右值屬性，根據(jù)其左右值屬性分別采用拷貝語(yǔ)義和移動(dòng)語(yǔ)義，移動(dòng)語(yǔ)義問(wèn)題便可以得到解決。

下面用MemoryBlock這個(gè)自我管理內(nèi)存塊的類來(lái)具體說(shuō)明移動(dòng)語(yǔ)義問(wèn)題。

#include <iostream> 
class MemoryBlock 
{ 
public: 
  // 構(gòu)造器（初始化資源） 
  explicit MemoryBlock(size_t length) 
    : _length(length) 
    , _data(new int[length]) 
  { 
  } 
  // 析構(gòu)器（釋放資源） 
  ~MemoryBlock() 
  { 
    if (_data != nullptr) 
    { 
      delete[] _data; 
    } 
  } 
  // 拷貝構(gòu)造器（實(shí)現(xiàn)拷貝語(yǔ)義：拷貝that） 
  MemoryBlock(const MemoryBlock& that) 
    // 拷貝that對(duì)象所擁有的資源 
    : _length(that._length) 
    , _data(new int[that._length]) 
  { 
    std::copy(that._data, that._data + _length, _data); 
  } 
  // 拷貝賦值運(yùn)算符（實(shí)現(xiàn)拷貝語(yǔ)義：釋放this ＋ 拷貝that） 
  MemoryBlock& operator=(const MemoryBlock& that) 
  { 
    if (this != &that) 
    { 
      // 釋放自身的資源 
      delete[] _data; 
      // 拷貝that對(duì)象所擁有的資源 
      _length = that._length; 
      _data = new int[_length]; 
      std::copy(that._data, that._data + _length, _data); 
    } 
    return *this; 
  } 
  // 移動(dòng)構(gòu)造器（實(shí)現(xiàn)移動(dòng)語(yǔ)義：移動(dòng)that） 
  MemoryBlock(MemoryBlock&& that) 
    // 將自身的資源指針指向that對(duì)象所擁有的資源 
    : _length(that._length) 
    , _data(that._data) 
  { 
    // 將that對(duì)象原本指向該資源的指針設(shè)為空值 
    that._data = nullptr; 
    that._length = 0; 
  } 
  // 移動(dòng)賦值運(yùn)算符（實(shí)現(xiàn)移動(dòng)語(yǔ)義：釋放this ＋ 移動(dòng)that） 
  MemoryBlock& operator=(MemoryBlock&& that) 
  { 
    if (this != &that) 
    { 
      // 釋放自身的資源 
      delete[] _data; 
      // 將自身的資源指針指向that對(duì)象所擁有的資源 
      _data = that._data; 
      _length = that._length; 
      // 將that對(duì)象原本指向該資源的指針設(shè)為空值 
      that._data = nullptr; 
      that._length = 0; 
    } 
    return *this; 
  } 
private: 
  size_t _length; // 資源的長(zhǎng)度 
  int* _data; // 指向資源的指針，代表資源本身 
}; 
MemoryBlock f() { return MemoryBlock(50); } 
int main() 
{ 
  MemoryBlock a = f();      // 調(diào)用移動(dòng)構(gòu)造器，移動(dòng)語(yǔ)義 
  MemoryBlock b = a;       // 調(diào)用拷貝構(gòu)造器，拷貝語(yǔ)義 
  MemoryBlock c = std::move(a);  // 調(diào)用移動(dòng)構(gòu)造器，移動(dòng)語(yǔ)義 
  a = f();            // 調(diào)用移動(dòng)賦值運(yùn)算符，移動(dòng)語(yǔ)義 
  b = a;             // 調(diào)用拷貝賦值運(yùn)算符，拷貝語(yǔ)義 
  c = std::move(a);        // 調(diào)用移動(dòng)賦值運(yùn)算符，移動(dòng)語(yǔ)義 
} 

轉(zhuǎn)發(fā)型引用

如果某個(gè)變量或參數(shù)被聲明為T(mén)&&類型，并且T需要經(jīng)過(guò)推導(dǎo)才可確定，那么這個(gè)變量或參數(shù)就是一個(gè)轉(zhuǎn)發(fā)型引用（forwarding reference）。

轉(zhuǎn)發(fā)型引用由以下兩種語(yǔ)法形式產(chǎn)生

• 如果某個(gè)變量被聲明為auto&&類型，那么這個(gè)變量就是一個(gè)轉(zhuǎn)發(fā)型引用
  
• 在函數(shù)模板中，如果某個(gè)參數(shù)被聲明為T(mén)&&類型，并且T是一個(gè)需要經(jīng)過(guò)推導(dǎo)才可確定的模板參數(shù)類型，那么這個(gè)參數(shù)就是一個(gè)轉(zhuǎn)發(fā)型引用

轉(zhuǎn)發(fā)型引用是不穩(wěn)定的，它的實(shí)際類型由它所綁定的值來(lái)確定。轉(zhuǎn)發(fā)型引用既可以綁定左值，也可以綁定右值。如果綁定左值，轉(zhuǎn)發(fā)型引用就成了左值引用。如果綁定右值，轉(zhuǎn)發(fā)型引用就成了右值引用。
轉(zhuǎn)發(fā)型引用在被C++標(biāo)準(zhǔn)所承認(rèn)之前曾經(jīng)被稱作萬(wàn)能引用（universal reference）。萬(wàn)能引用這一術(shù)語(yǔ)的發(fā)明者，Effective C++系列的作者Scott Meyers認(rèn)為，如此異常靈活的引用類型不屬于右值引用，它應(yīng)該擁有自己的名字。

對(duì)于某個(gè)轉(zhuǎn)發(fā)型引用類型的變量（auto&&類型）來(lái)說(shuō)

• 如果初始化表達(dá)式為左值（類型為U&），該變量將成為左值引用（類型為U&）。
• 如果初始化表達(dá)式為右值（類型為U&&），該變量將成為右值引用（類型為U&&）。

對(duì)于函數(shù)模板中的某個(gè)轉(zhuǎn)發(fā)型引用類型的形參（T&&類型）來(lái)說(shuō)

• 如果對(duì)應(yīng)的實(shí)參為左值（類型為U&），模板參數(shù)T將被推導(dǎo)為引用類型U&，該形參將成為左值引用（類型為U&）。
• 如果對(duì)應(yīng)的實(shí)參為右值（類型為U&&），模板參數(shù)T將被推導(dǎo)為非引用類型U，該形參將成為右值引用（類型為U&&）。
  

struct X {}; 
X&& var1 = X();              // var1是右值引用，只能綁定右值X() 
auto&& var2 = var1;            // var2是轉(zhuǎn)發(fā)型引用，可以綁定左值var1 
                      // var2的實(shí)際類型等同于左值var1，即X& 
auto&& var3 = X();             // var3是轉(zhuǎn)發(fā)型引用，可以綁定右值X() 
                      // var3的實(shí)際類型等同于右值X()，即X&& 
template<typename T> 
void g(std::vector<typename T>&& param1); // param1是右值引用 
template<typename T> 
void f(T&& param2);            // param2是轉(zhuǎn)發(fā)型引用 
X a; 
f(a);        // 模板函數(shù)f()的形參param2是轉(zhuǎn)發(fā)型引用，可以綁定左值a 
           // 在此次調(diào)用中模板參數(shù)T將被推導(dǎo)為引用類型X& 
           // 而形參param2的實(shí)際類型將等同于左值a，即X& 
f(X());       // 模板函數(shù)f()的形參param2是轉(zhuǎn)發(fā)型引用，可以綁定右值X() 
           // 在此次調(diào)用中模板參數(shù)T將被推導(dǎo)為非引用類型X 
           // 而形參param2的實(shí)際類型將等同于右值X()，即X&& 
// 更多右值引用和轉(zhuǎn)發(fā)型引用 
const auto&& var4 = 10;              // 右值引用 
template<typename T> 
void h(const T&& param1);             // 右值引用 
template <typename T/*, class Allocator = allocator*/> 
class vector 
{ 
public: 
  void push_back( T&& t );           // 右值引用 
  template <typename Args...> 
  void emplace_back( Args&&... args );     // 轉(zhuǎn)發(fā)型引用 
}; 

完美轉(zhuǎn)發(fā)

完美轉(zhuǎn)發(fā)（perfect forwarding）問(wèn)題是指函數(shù)模板在向其他函數(shù)轉(zhuǎn)發(fā)（傳遞）自身參數(shù)（形參）時(shí)該如何保留該參數(shù)（實(shí)參）的左右值屬性的問(wèn)題。也就是說(shuō)函數(shù)模板在向其他函數(shù)轉(zhuǎn)發(fā)（傳遞）自身形參時(shí)，如果相應(yīng)實(shí)參是左值，它就應(yīng)該被轉(zhuǎn)發(fā)為左值；同樣如果相應(yīng)實(shí)參是右值，它就應(yīng)該被轉(zhuǎn)發(fā)為右值。這樣做是為了保留在其他函數(shù)針對(duì)轉(zhuǎn)發(fā)而來(lái)的參數(shù)的左右值屬性進(jìn)行不同處理（比如參數(shù)為左值時(shí)實(shí)施拷貝語(yǔ)義；參數(shù)為右值時(shí)實(shí)施移動(dòng)語(yǔ)義）的可能性。如果將自身參數(shù)不分左右值一律轉(zhuǎn)發(fā)為左值，其他函數(shù)就只能將轉(zhuǎn)發(fā)而來(lái)的參數(shù)視為左值，從而失去針對(duì)該參數(shù)的左右值屬性進(jìn)行不同處理的可能性。

轉(zhuǎn)發(fā)型引用的引入主要是為了解決完美轉(zhuǎn)發(fā)問(wèn)題。在函數(shù)模板中需要保留左右值屬性的參數(shù)，也就是要被完美轉(zhuǎn)發(fā)的參數(shù)須被聲明為轉(zhuǎn)發(fā)型引用類型，即參數(shù)必須被聲明為T(mén)&&類型，而T必須被包含在函數(shù)模板的模板參數(shù)列表之中。按照轉(zhuǎn)發(fā)型引用類型形參的特點(diǎn)，該形參將根據(jù)所對(duì)應(yīng)的實(shí)參的左右值屬性而分別蛻變成左右值引用。但無(wú)論該形參成為左值引用還是右值引用，該形參在函數(shù)模板內(nèi)都將成為左值。這是因?yàn)樵撔螀⒂忻?，左值引用是左值，具名右值引用也同樣是左值。如果在函?shù)模板內(nèi)照原樣轉(zhuǎn)發(fā)該形參，其他函數(shù)就只能將轉(zhuǎn)發(fā)而來(lái)的參數(shù)視為左值，完美轉(zhuǎn)發(fā)任務(wù)將會(huì)失敗。

#include<iostream> 
using namespace std; 
struct X {}; 
void inner(const X&) {cout << "inner(const X&)" << endl;} 
void inner(X&&) {cout << "inner(X&&)" << endl;} 
template<typename T> 
void outer(T&& t) {inner(t);} 
int main() 
{ 
  X a; 
  outer(a); 
  outer(X()); 
} 
//inner(const X&) 
//inner(const X&) 
std::forward()

要在函數(shù)模板中完成完美轉(zhuǎn)發(fā)轉(zhuǎn)發(fā)型引用類型形參的任務(wù)，我們必須在相應(yīng)實(shí)參為左值，該形參成為左值引用時(shí)把它轉(zhuǎn)發(fā)成左值，在相應(yīng)實(shí)參為右值，該形參成為右值引用時(shí)把它轉(zhuǎn)發(fā)成右值。此時(shí)我們需要標(biāo)準(zhǔn)庫(kù)函數(shù)std::forward()。

標(biāo)準(zhǔn)庫(kù)函數(shù) std::forward<T>(t) 有兩個(gè)參數(shù)：模板參數(shù) T 與 函數(shù)參數(shù) t。函數(shù)功能如下：

• 當(dāng)T為左值引用類型U&時(shí)，t 將被轉(zhuǎn)換為無(wú)名左值引用（左值，類型為U&）。
• 當(dāng)T為非引用類型U或右值引用類型U&&時(shí)，t 將被轉(zhuǎn)換為無(wú)名右值引用（右值，類型為U&&）。

使用此函數(shù)，我們?cè)诤瘮?shù)模板中轉(zhuǎn)發(fā)類型為T(mén)&&的轉(zhuǎn)發(fā)型引用參數(shù) t 時(shí)，只需將參數(shù) t 替換為std::forward<T>(t)即可完成完美轉(zhuǎn)發(fā)任務(wù)。這是因?yàn)?br />

• 如果 t 對(duì)應(yīng)的實(shí)參為左值（類型為U&），模板參數(shù)T將被推導(dǎo)為引用類型U&，t 成為具名左值引用（類型為U&），std::forward<T>(t)就會(huì)把 t 轉(zhuǎn)換成無(wú)名左值引用（左值，類型為U&）。
• 如果 t 對(duì)應(yīng)的實(shí)參為右值（類型為U&&），模板參數(shù)T將被推導(dǎo)為非引用類型U，t 成為具名右值引用（類型為U&&），std::forward<T>(t)就會(huì)把 t 轉(zhuǎn)換成無(wú)名右值引用（右值，類型為U&&）。

#include<iostream> 
using namespace std; 
struct X {}; 
void inner(const X&) {cout << "inner(const X&)" << endl;} 
void inner(X&&) {cout << "inner(X&&)" << endl;} 
template<typename T> 
void outer(T&& t) {inner(forward<T>(t));} 
int main() 
{ 
  X a; 
  outer(a); 
  outer(X()); 
} 
//inner(const X&) 
//inner(X&&) 

總結(jié)

以上所述是小編給大家介紹的C++11右值引用和轉(zhuǎn)發(fā)型引用教程詳解，希望對(duì)大家有所幫助，如果大家有任何疑問(wèn)請(qǐng)給我留言，小編會(huì)及時(shí)回復(fù)大家的。在此也非常感謝大家對(duì)腳本之家網(wǎng)站的支持！

最新評(píng)論