一.什么是左值引用 右值引用
1.左值引用
左值是一个表示数据的表达式(如变量名或解引用的指针),我们可以获取它的地址+可以对它赋值。定义时const修饰符后的左值,不能给他赋值,但是可以取它的地址。左值引用就是给左值的引用,给左值取别名。
int main()
{
// 以下的p、b、c、*p都是左值
int* p = new int(0);
int b = 1;
const int c = 2;
// 以下几个是对上面左值的左值引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pvalue = *p;
return 0;
}
2.右值引用
右值也是一个表示数据的表达式,如:字面常量、表达式返回值,函数返回值(这个不能是左值引用返回)等等,右值可以出现在赋值符号的右边,但是不能出现出现在赋值符号的左边,右值不能取地址。右值引用就是对右值的引用,给右值取别名。
int main()
{
double x = 1.1, y = 2.2;
// 以下几个都是常见的右值
10;
x + y;
fmin(x, y);
// 以下几个都是对右值的右值引用
int&& rr1 = 10; //常量
double&& rr2 = x + y; //临时变量
double&& rr3 = fmin(x, y); //临时变量
// 这里编译会报错:error C2106: “=”: 左操作数必须为左值
10 = 1;
x + y = 1;
fmin(x, y) = 1;
return 0;
}
区分左值右值关键就看能否取地址,左值可以取地址,右值不能取地址。
注意:
int&& rr1=10 10是常量是右值,那rr1是右值吗?rr1是左值,因为rr1要有空间存储10,所以有地址。可以对它本身进行修改,但有const 修饰的,const int&& rr1不能。
左值/右值引用引用的一定是左值/右值吗?
1.左值
1. 左值引用只能引用左值,不能引用右值。
2. 但是const左值引用既可引用左值,也可引用右值。
int main()
{
// 左值引用只能引用左值,不能引用右值。
int a = 10;
int& ra1 = a; // ra为a的别名
//int& ra2 = 10; // 编译失败,因为10是右值
// const左值引用既可引用左值,也可引用右值。
const int& ra3 = 10;
const int& ra4 = a;
return 0;
}
2.右值
1. 右值引用只能右值,不能引用左值。
2. 但是右值引用可以move以后的左值。(move原理和强转一致,只是把左值属性转换成右值,在底层实现时左值右值没有区别,只是为了编译通过)
int main()
{
// 右值引用只能右值,不能引用左值。
int&& r1 = 10;
// error C2440: “初始化”: 无法从“int”转换为“int &&”
// message : 无法将左值绑定到右值引用
int a = 10;
//int&& r2 = a;
// 右值引用可以引用move以后的左值
int&& r3 = std::move(a);
return 0;
}
二.左值引用使用场景
当我们进行传参,函数返回值时 直接引用就可以减少拷贝,提高效率。
void func1(bit::string s)
{}
void func2(const bit::string& s)
{}
int main()
{
bit::string s1("hello world");
// func1和func2的调用我们可以看到左值引用做参数减少了拷贝,提高效率的使用场景和价值
func1(s1);
func2(s1);
// string operator+=(char ch) 传值返回存在深拷贝
// string& operator+=(char ch) 传左值引用没有拷贝提高了效率
s1 += '!';
return 0;
}
左值引用的短板:
当函数返回值是一个局部变量,出了作用域就会销毁,这样返回的左值引用就没有意义了,只能进行拷贝 传值返回。
string operator+(const string& s, char ch) { string ret(s); ret.push_back(ch); return ret; }
ret左值出了作用域就会销毁
三.右值引用使用场景
在C++11前都是在mian()函数中定义ret再传给operator+(),延长生命周期。
之后引出了右值引用和移动语义来解决。
1.移动语义
将一个对象的资源转到另一个对象上。
1.移动构造
移动构造和拷贝构造区别在于,移动构造只能接受右值/move(左值) 。而拷贝构造左值右值(const)都可以接收。 当我们传右值编译器会优先匹配更符合的 移动构造。
我们知道to_string中创建的str左值,但马上被销毁,编译器会自动识别为右值,属于将亡值。这样就可以走移动构造转移资源 减少拷贝。
2.移动赋值
用常量1234初始化会调用移动构造,to_string返回值再通过移动复制将资源转移到ret1上。
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动语义" << endl;
swap(s);
return *this;
}
int main()
{
bit::string ret1;
ret1 = bit::to_string(1234);
return 0;
}
// 运行结果:
// string(string&& s) -- 移动语义
// string& operator=(string&& s) -- 移动语义
四.完美转发
万能引用
首先我们要了解什么是万能引用。
确定类型的 && 表示右值引用(比如:int&& ,string&&),
但函数模板中的 && 不表示右值引用,而是万能引用,模板类型必须通过推断才能确定,其接收左值后会被推导为左值引用,接收右值后会被推导为右值引用。
template<typename T>
void f(T&& t) // 万能引用
{
//...
}
int main()
{
int a = 5; // int 左值
f(a); // 传参后int&
const string s("hello"); // const string 左值
f(s); // 传参后const string&
f(to_string(1234)); // 右值 传参后 string&&
return 0;
}
注意区分右值引用和万能引用:下面的函数的 T&& 并不是万能引用,因为 T 的类型在模板实例化时已经确定。
template<class T>
class A
{
void func(T&& a)
{
}
};
for_ward()
为什么都调用的左值引用呢?
因为在传参时右值变为了左值,导致调用Fun()函数时t参数的属性永远是左值。
这时候就需要forward<T>()完美转发,保持参数属性,左值还是左值,右值还是右值。