當你在學習語言的時候，是否經(jīng)常聽到過一種說法,"="左邊的叫做左值，"="右邊的叫做右值。這句話對嗎？從某種意義上來說，這句話只是說對了一部分。

---前言

一、什么是左右值?

通常認為:
左值是一個表示數(shù)據(jù)的表達式(如變量名或解引用的指針)，我們可以獲取它的地址+可以對它賦
值(使用空間)，左值可以出現(xiàn)賦值符號的左邊，也可以出現(xiàn)在等號右邊。

右值也是一個表示數(shù)據(jù)的表達式，如：字面常量、表達式返回值，函數(shù)返回值等等。右值可以出現(xiàn)在賦值符號的右邊，但是不能出現(xiàn)在賦值符號的左邊，右值不能取地址。

    //x \ y 都是左值 都可以取地址double x = 1.1, y = 2.2;int a = 10,b = 20;//以下都是右值 都不用取地址10;x + y;func();

二、左右值引用

(1)左值引用

type& x;

在我們學習引用的時候，一定會和C語言的指針聯(lián)系到一起。我們來看看下面的swap代碼吧。

void SwapByPtr(int* a,int* b)
{int tmp = *a;*a = *b;*b = tmp;
}void SwapByVal(int a, int b)
{int tmp = a;a = b;b = a;
}

結(jié)果我想你一定知道的！函數(shù)傳值與函數(shù)傳地址是不同的！一個是一份拷貝，一個是記錄的地址，可以訪問原變量。

但是我們知道，指針是有它的缺陷，如果不是一位資深程序員，甚至你是，也得對指針的使用報以"敬畏之心"。因此，在C++中引入了新的語法，"引用"。雖然它底層仍然是用指針實現(xiàn)的，但是卻比指針用起來更加方便。

void SwapByRef(int& a,int& b)
{int tmp = a;a = b;b = a;
}

(2)右值引用

我們時常說"引用","引用"，其實都是"左值引用"。為了區(qū)別左值引用呢，右值引用的語法格式上是這樣的。

type &&;

    int a = 10;int& ra = a;? ? ? ?  //左值引用int&& rra = 10;? ??  //右值引用

(3)左右值引用的特性

左值引用:
①只能引用左值，不能引用右值
②但是const左值引用 可以引用右值也可以引用左值

    int a = 10;int& ra = a;? ? ? ?   //只能引用左值int& rb1 = 10;? ?     //不能引用右值 ×//既可以引用左值、也可以引用右值const int& rb2 = a;const int& rb2 = 10; 

右值引用:
①右值引用只能引用右值，不能引用左值
②標準庫中提供move()函數(shù)，可以將一個左值變?yōu)橛抑?/blockquote>

    int a = 10;int&& rra1 = 10;? ? //只能引用右值 int&& rra2 = a; ? ? //不能引用左值 ×//move后可以 a變成了右值int&& rra3 = std::move(a);

右值不能取地址，但是右值引用能夠取地址!!

右值當然沒有地址，但是我們給右值取引用時，那么這個右值引用就該有它的地址，并且可以對它引用的對象進行修改。如果你不想允許讓對右值引用的值發(fā)生改變，請給它+"const"吧。
為什么這么設(shè)計呢？這和右值引用的場景有關(guān)，也就是我們之后要細講的。

當然，這很符合我們的預期。

---

三、左右值引用的應用場景

也許你會疑問，已經(jīng)有了左值引用，為什么還需要右值引用呢？右值引用一定有它存在必要的場景。在此之前，我們就先來列舉列舉左值引用的使用場景吧。

左值引用場景:
①函數(shù)傳參防拷貝。
②函數(shù)返回值 引用返回。

//函數(shù)傳參防拷貝
vector<int>& Func(vector<int>& ret)
{ret.push_back(1);//...//函數(shù)引用返回值return ret;
}

當要進行左值引用返回時，唯一一個條件時，該對象出了作用域仍然存在！那如果該對象就是在函數(shù)體內(nèi)創(chuàng)建的，出了作用域它就會銷毀，但其拷貝的代價又很大。遇到這樣的情況，我們應該怎么處理呢？

(1)移動賦值與移動構(gòu)造

我們首先實現(xiàn)一個to_string的函數(shù)，用來將一個數(shù)字，轉(zhuǎn)換為自定義字符串。

//to_string函數(shù)string to_string(int value){bool flag = true;if (value < 0){flag = false;value = 0 - value;}dy::string str;while (value > 0){int x = value % 10;value /= 10;str += ('0' + x);}if (flag == false){str += '-';}std::reverse(str.begin(), str.end());return str;}

//自定義string 類class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}string(const char* str = ""):_size(strlen(str)), _capacity(_size){_str = new char[_capacity + 1];strcpy(_str, str);}// s1.swap(s2)void swap(string& s){::swap(_str, s._str);::swap(_size, s._size);::swap(_capacity, s._capacity);}// 拷貝構(gòu)造string(const string& s){cout << "string(const string& s) -- 深拷貝" << endl;string tmp(s._str);swap(tmp);}// 賦值重載string& operator=(const string& s){cout << "string& operator=(string s) -- 深拷貝" << endl;string tmp(s);swap(tmp);return *this;}~string(){delete[] _str;_str = nullptr;}char& operator[](size_t pos){assert(pos < _size);return _str[pos];}void reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}void push_back(char ch){if (_size >= _capacity){size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}_str[_size] = ch;++_size;_str[_size] = '\0';}//string operator+=(char ch)string& operator+=(char ch){push_back(ch);return *this;}const char* c_str() const{return _str;}private:char* _str = nullptr;size_t _size = 0;size_t _capacity = 0; // 不包含最后做標識的\0};

我們此時用一個整數(shù)，使用to_string函數(shù)，得到一個自定義string類型。

int main()
{int x = 1234;dy::string ret = dy::to_string(x);return 0;
}

但是，我們?yōu)榱艘粋€在to_string函數(shù)類，一個出作用域就會銷毀的對象，為了得到它其中的資源，就得付出"深拷貝"一份的代價，未免有些太大。

如果僅僅是拷貝內(nèi)置類型來說，那么微乎其微，但如果深拷貝對象是map、set呢？也許你僅僅只需要得到這個即將銷毀對象的"根節(jié)點"即可，而非是在return返回時，讓該對象拷貝構(gòu)造臨時對象而付出巨大代價。

秉持這樣的想法，我們?yōu)樵撟远x類設(shè)計一個新的拷貝構(gòu)造函數(shù)。

        //移動賦值與移動構(gòu)造string(string&& s){cout << "string(string&& s): 移動構(gòu)造" << endl;swap(s);}string& operator=(string&& s){cout << "string& operator=(string s) 移動賦值" << endl;swap(s);return *this;}

我們?yōu)樵擃愒黾舆@兩個函數(shù)，并再次運行相同的代碼。

這是為什么？？該對象的"拷貝"沒有選擇去調(diào)用"深拷貝"？那么，我們不得不搞懂以下的三個問題！

能夠搞懂上述的問題，我們也就能夠預知編譯器會選擇怎樣做。

那如果是以下這樣的調(diào)用，會打印出什么呢？

int main()
{    dy::string ret2;ret2 = dy::to_string(123);return 0;
}

小結(jié):

左值引用與右值引用減少拷貝的方式是不一樣的：

左值引用是直接起作用的，就是給一個變量取別名。

右值引用是間接起作用的，利用移動構(gòu)造、移動賦值實現(xiàn)的是一種資源的轉(zhuǎn)移。而被轉(zhuǎn)移的資源也叫做"將亡值"。也就是出了這個作用域，就會銷毀的對象。

---

四、左右值引用的其他應用

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

在前文已經(jīng)提到過，一旦給右值取別名時，那么該右值引用名義上雖然是右值的別名，但本質(zhì)是一個可以取地址、甚至可以改變的左值。我們來看看如下的代碼。

void Func(int& x)
{cout << "左值引用" << endl;
}void Func(int&& x)
{cout << "右值引用" << endl;
}void GetFunc(int&& x)
{Func(x);
}int main()
{int a = 10;GetFunc(10);return 0;
}

唔，我們分別重載了兩個函數(shù)Func,一個是用來接收左值引用的、一個是來接收右值引用的，我們傳進來的是一個右值10，那么很顯然調(diào)用后打印的是 "右值引用"。

當右值引用作為參數(shù)時，雖然名義上接收的是右值，但是向下傳遞時，已經(jīng)改變?yōu)榱俗笾?。但是我們就想讓它保持原有的屬性?/p>

C++庫中給提供了一個函數(shù)轉(zhuǎn)發(fā)
std::forward<type>();

我們也就可以看到如我們的預期結(jié)果。

(2)萬能引用

函數(shù)參數(shù)有左值引用、也有右值引用，C++中也有模板，那是否模板也有模板左值引用與模板右值引用呢？ 是的！

template<class T>
void PerfectFunc(T& x)
{Func(x);
}

template<class T>
void PerfectFunc(const T& x)
{Func(x);
}

但其實這都用得不多。因為接下來的操作可能會驚掉你的下把。

template<class T>
void PerfectFunc(T&& x)
{Func(x);
}

這什么鬼？？？

在有模板的情況下;
template<class T>
void Func(T&& ..);
就叫做 "萬能引用！"

當然，如果你沒好好閱讀上文，你可能還會驚奇，為什么只會調(diào)用左值引用與const左值引用。我們只需要讓向下傳入的值保持原屬性即可。

由此可見，我們能萬能引用的情況下，肯定不會去選擇"T&"這單調(diào)的左值引用參數(shù)。

---

總結(jié):

①左右值區(qū)分的最根本方法是，能否取地址，能否使用它的空間。

②左值引用只能引用左值,右值引用只能引用右值。但是const 左值引用可以引用左值 也可以引用右值。

③右值一定沒有地址并且不能修改，但是右值引用有它自己的地址，非const可以進行修改。

④左值引用的防拷貝方式更加直接顯著。右值引用防拷貝的方式是間接的，也叫"資源轉(zhuǎn)移"。

⑤std::move()可以將一個左值變?yōu)橛抑?。std::forward<T>()能保持參數(shù)的原屬性。

本篇到此結(jié)束，感謝你的閱讀。

祝你好運，向陽而生~