文章目录
- 一、左值与右值
- 1.概念
- 2.引用
- 3.注意
- 二、右值引用的意义
- 1.左值引用意义
- 2.右值引用和移动语义
- 3.容器新增
- 三、万能引用
- 四、完美转发
一、左值与右值
1.概念
左值是什么？右值是什么？
左值是一个表示数据的表达式（如
变量名或解引用的指针）我们可以获取它的地址，可以对它赋值.（const修饰后的左值不能给它赋值）
注意：左值既可以出现在赋值符号的左边，也可以出现在赋值符号的右边
int main()
{
//左值
int a = 10;
const int c = 20;
a = c;
int* p = new int(0);
return 0;
}
右值也是一个表示数据的表达式，如：字面常量、表达式返回值、函数返回值（不能是左值引用返回）。
右值可以出现在赋值符号的右边，但是不能出现在赋值符号的左边，右值不能取地址。
int main()
{
double x = 1.1, y = 2.2;
//右值
10;
x + y;
func(x + y);
return 0;
}
2.引用
左值引用与右值引用
C++11中新增了右值引用的特性，为了区分，把C++11之前的引用称为左值引用。
无论是左值引用还是右值引用，本质都是在给对象取别名
- 左值引用
左值引用就是对左值的引用，给左值取别名，通过&来声明
int main()
{
//左值
int* p = new int(0);
int a = 1;
const int b = 2;
//左值引用
int*& rp = p;
int& rrp = *p;
int& ra = a;
const int& rb = b;
return 0;
}
- 右值引用
右值引用就是对右值的引用，给右值取别名，通过&&来声明
int main()
{
//右值
double x = 1.1, y = 2.2;
10;
x + y;
func(x, y);
//右值引用
int&& r1 = 10;
double&& r2 = x + y;
double&& r3 = func(x, y);
return 0;
}
3.注意
注意：
- 左值引用右值问题
左值不能引用右值，这会导致权限放大，右值可读不可写，而左值可读可写
但是有const修饰左值引用就能保证被引用的数据不会被修改了，所以const左值引用可以引用右值
所以const左值引用既可以引用左值，也可以引用右值:
int main()
{
int a = 10;
int& ra1 = a;
//int& ra2 = 10;//10是右值,不能被左值引用
//const左值引用既可以引用左值，也可引用右值
const int& ra4 = a;
const int& ra3 = 10;
return 0;
}
- 右值引用左值问题
右值引用只能引用右值，不能引用左值
但是右值引用可以引用move以后的左值
move函数是C++11提供的一个函数，被move后的左值就能被赋值给右值引用
int main()
{
//右值引用右值
int&& r1 = 10;
//右值引用move后的左值
int a = 10;
int&& r2 = move(a);
return 0;
}
了解一下：
为什么要有const右值引用：我们知道右值引用不可改变，那const右值引用有什么作用：
右值不可以取地址，但是右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，如果不想rr1被修改，那就可以用const int&&rr1去引用。右值不能取地址，引用之后变成左值了
int main()
{
double x = 1.1, y = 2.2;
//右值引用
int&& rr1 = 10;
const double&& rr2 = x + y;
rr1++;//可以被修改
//rr2++;//不可以被修改
cout<<&rr1<<endl;
cout<<&rr2<<endl;
return 0;
}
所以const右值引用的意义在于：右值不可修改，不可取地址；右值引用之后开空间存储下来，对于引用而言是左值，可以取地址，可以改变，这是为了移动构造，去移动换取资源，具体移动构造可见后面。
二、右值引用的意义
1.左值引用意义
左值引用的意义：
1.做函数参数：减少拷贝，提高效率，可做
输出型参数2.做函数返回值：减少拷贝，提高效率。引用返回，可修改返回对象
但是左值引用并没有彻底的解决问题：
左值引用左返回值时，并不能避免函数返回对象时不必要的拷贝操作
如果函数的返回的是一个局部的对象，该对象出了函数作用域就被销毁了，这种情况下就不能用左值引用作为返回值了，只能以传值的方式返回（深拷贝），这是左值引用的缺陷。
//左值引用尚未解决的问题场景
template<class T>
T func3(const T& x)
{
T ret;
//...
return ret;//返回局部对象，出作用域就会销毁
}
int main()
{
func3(v1);
return 0;
}
又比如to_string的模拟实现：
string to_string(int value)
{
bool flag = true;
if (value < 0)
{
flag = false;
value = 0 - value;
}
hwc::string str;
while (value > 0)
{
int x = value % 10;
value /= 10;
str += (x + '0');
}
if (flag == false)
{
str += '-';
}
std::reverse(str.begin(), str.end());
return str;
}
str是局部变量，除了作用域就会销毁：
hwc::string ret = hwc::to_string(-1234);
此时如果调用，就会调用string的拷贝构造函数
**所以C++11自然就会出手引出了右值引用：右值引用的意义之一就是为了补齐左值引用的这个短板：传值返回的拷贝问题。**其二对于插入一些插入右值数据，也可以减少拷贝。
2.右值引用和移动语义
C++11对右值进行了区分：纯右值与将亡值
- 内置类型表达式的值 ——
纯右值 - 自定义类型表达式的值——
将亡值
移动构造：移动构造也是一个构造函数，该构造函数的参数是右值引用，移动构造实际就是把传入右值的资源转移过来，避免了深拷贝，所以称为移动构造，就是移动别人的资源来进行构造
//拷贝构造
string(const string& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
cout << "string(const string& s)->深拷贝" << endl;
string tmp(s._str);
swap(tmp);//this->swap(tmp)
}
//移动构造
string(string&& s)//右值引用
:_str(nullptr)
,_size(0)
,_capacity(0)
{
cout << "string(const string& s) -- 移动拷贝" << endl;
swap(s);
}
int main()
{
hwc::string s1("hello world");
hwc::string s2(s1);//拷贝构造
//move之后变成右值。将亡值
hwc::string s3(move(s1));//移动构造
return 0;
}
把s1移动到s3中去了，移动将亡值。
移动构造的意义:
没有移动构造之前，拷贝构造采用const左值引用来接收，所以无论是左值还是右值都会调用拷贝构造
有了移动构造之后，采用的是右值引用接收，如果传入右值，就会调用移动构造
string的拷贝构造是深拷贝，而移动构造是通过swap函数移动资源，所以调用移动构造的代价消耗更小
这个时候成本大大降低，无需深拷贝，直接资源转移。
编译器优化问题，这是之前说过的，这里重新复习一下：
如果返回局部对象时，会先用这个局部对象拷贝构造出一个临时对象，然后再用这个临时对象来拷贝构造我们接收返回值的对象；
编译器会优化成：只需要一次拷贝构造：
ps:右值引用swap()的是将亡值，拷贝构造中不能直接swap,因为对象不是将亡值：
int main()
{
hwc::string s1("12345");
hwc::string s2(s1);
return 0;
}
移动赋值
移动赋值就是一个赋值运算符重载函数，参数是右值引用类型，移动赋值就是将传入右值的资源转移过来，这样就避免了深拷贝，这也是移动赋值的由来。
//operator=
string& operator=(const string& s)
{
cout << "string& operator=(string s) -- 深拷贝" << endl;
string tmp(s);
swap(tmp);
return *this;
}
//移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s)->移动赋值拷贝" << endl;
swap(s);
return *this;
}
int main()
{
hwc::string ret;
ret = hwc::to_string(-1234);
}
移动赋值的意义:
没有移动赋值前，原先operator=采用的是const左值引用接收参数，所以无论赋值时传入左值还是右值都会调用原来的operator=。但是移动赋值采用了右值引用接收参数，所以如果赋值时传入的是右值，那么调用的就是移动赋值函数。而string原来的operator=是深拷贝，而移动赋值通过swap把资源进行转移，代价比原先的operator=代价小。
to_string返回局部对象时，调用移动构造生成一个临时对象，然后在调用移动赋值将临时对象资源转移到接收返回值的对象上，这个过程调用了两个函数但却只是资源的移动，不需要进行深拷贝。（右值引用延长生命周期：资源延长了）
总结：右值引用和左值引用减少拷贝的原理不太一样。左值引用是取别名直接起作用，右值引用是间接起作用，实现移动构造和移动赋值，在拷贝的场景中如果是右值（将亡值），转移资源。
3.容器新增
C++11之后，STL中容器就增加了移动构造与移动赋值：
比如string新增移动构造
比如string新增移动赋值
另外，C++11为STL容器的插入接口也增加了右值引用：
我们来看一看区别：在hwc命名空间里list插入接口没有实现右值引用：
在std里list插入接口实现了右值引用：
string类提供了移动构造函数，并且容器的push_back接口提供了右值引用版本，如果push_back函数传入的参数string对象也是一个右值，那么push_back函数就可以通过string的移动构造函数来进行资源的转移，避免了深拷贝，提高效率。
三、万能引用
右值引用本身是左值。
模板中&&并不是右值引用，而是万能引用，既能接收左值也能接收右值，同时也能接收const左值、const右值：
//万能引用
template <typename T>
void PerfectForward(T&& t)
{
}
int main()
{
int x = 1;
PerfectForward(x);//左值
PerfectForward(10);//右值
PerfectForward(move(x));//右值
const int y = 20;
PerfectForward(y);//const左值
PerfectForward(move(y));//const右值
return 0;
}
万能引用会根据传入实参的类型进行推导，如果传入的实参是一个左值，那么这里的形参t就是左值引用，如果传入的实参是一个右值，那么这里的形参t就是右值引用，同时t是可以++的，而如果加上const左值、cosnt右值t就不可以++。举个例子：
void Func(int& x)
{
cout << "左值引用" << endl;
}
void Func(const int& x)
{
cout << "const 左值引用" << endl;
}
void Func(int&& x)
{
cout << "右值引用" << endl;
}
void Func(const int&& x)
{
cout << "const 右值引用" << endl;
}
template<class T>
void PerfectForward(T&& t)
{
Func(t);
}
int main()
{
int x = 1;
PerfectForward(x);//左值
PerfectForward(10);//右值，右值引用再传递时属性是左值
PerfectForward(move(x));//右值
const int y = 20;
PerfectForward(y);//const左值
PerfectForward(move(y));//const右值
return 0;
}
PerfectForward传递的参数分别是左值、右值、右值、const左值、const右值，但是结果都是左值
这是因为右值引用后会导致右值被存储到特定的位置，此时右值具有左值的属性，可以被取地址也可以被修改，所以PerfectForward函数调用Func函数会将t识别为左值。
而如果想要在传递参数的过程之中保持右值的属性，这就需要用到完美转发了。
四、完美转发
如果想要在参数传递的过程中保持其原有的属性，则需要在传参时调用forward函数：
void Func(int& x)
{
cout << "左值引用" << endl;
}
void Func(const int& x)
{
cout << "const 左值引用" << endl;
}
void Func(int&& x)
{
cout << "右值引用" << endl;
}
void Func(const int&& x)
{
cout << "const 右值引用" << endl;
}
template<class T>
void PerfectForward(T&& t)
{
Func(std::forward<T>(t));
}
int main()
{
int x = 1;
PerfectForward(x);//左值
PerfectForward(10);//右值，右值引用再传递时属性是左值
PerfectForward(move(x));//右值
const int y = 20;
PerfectForward(y);//const左值
PerfectForward(move(y));//const右值
return 0;
}
用完美转发给简化list提供右值引用的push_back与insert接口：
namespace hwc
{
template <class T>
struct list_node
{
list_node<T>* _next;
list_node<T>* _prev;
T _data;
list_node(const T& x)
:_next(nullptr)
, _prev(nullptr)
, _data(x)
{
}
//右值引用
list_node(T&& x)
:_next(nullptr)
, _prev(nullptr)
, _data(forward<T>(x))//完美转发
{
}
};
template<class T, class Ref, class Ptr>
struct __list_iterator
{
typedef list_node<T> node;
typedef __list_iterator<T, Ref, Ptr> Self;
node* _pnode;
__list_iterator(node*p)
:_pnode(p)
{
}
//......
};
template<class T>
class list
{
typedef list_node<T> node;
public:
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
iterator begin()
{
return iterator(_head->_next);
}
iterator end()
{
return iterator(_head);
}
void empty_initialize()
{
_head = new node(T());
_head->_next = _head;
_head->_prev = _head;
_size = 0;
}
list()
{
empty_initialize();
}
//左值引用
void push_back(const T& x)
{
insert(end(), x);
}
//右值引用
void push_back(T&& x)
{
insert(end(), forward<T>(x));//完美转发
}
//左值引用
iterator insert(iterator pos,const T& x)
{
node* newnode = new node(x);
node* cur = pos._pnode;
node* prev = cur->_prev;
newnode->_prev = prev;
prev->_next = newnode;
newnode->_next = cur;
cur->_prev = newnode;
++_size;
return iterator(newnode);
}
//右值引用
iterator insert(iterator pos, T&& x)
{
node* newnode = new node(forward<T>(x));//完美转发
node* cur = pos._pnode;
node* prev = cur->_prev;
newnode->_prev = prev;
prev->_next = newnode;
newnode->_next = cur;
cur->_prev = newnode;
++_size;
return iterator(newnode);
}
private:
node* _head;
size_t _size;
};
}
int main()
{
hwc::list<hwc::string> lt;
hwc::string s1("111111");
lt.push_back(s1);//左值——深拷贝
lt.push_back(hwc::string("222222"));
lt.push_back("3333333");
return 0;
}
本篇结束…
