C++11语法介绍 -- 右值引用和移动语义
C++11引入了右值引用和移动语义，通过区分左值（可寻址的持久对象）和右值（临时对象或字面量）来优化资源管理。左值引用用于为左值取别名，而右值引用则专门处理临时对象。const左值引用可以绑定右值，但右值引用需通过move强制转换来引用左值。右值引用能延长临时对象的生命周期并允许修改，而const左值引用仅延长生命周期。移动构造函数和移动赋值运算符通过“窃取”右值资源而非拷贝，显著提升了深拷贝类（
·
右值引用和移动语义
C++98的C++语法中就有引⽤的语法，⽽C++11中新增了的右值引⽤语法性，C++11之后我们之前学习的引⽤就叫做左值引⽤。⽆论左值引⽤还是右值引⽤，都是给对象取别名。
左值和右值
左值：⼀个表⽰数据的表达式(如变量名或解引⽤的指针)，⼀般是有持久状态，存储在内存中，我
们可以获取它的地址，左值可以出现赋值符号的左边，也可以出现在赋值符号右边。定义时const
修饰符后的左值，不能给他赋值，但是可以取它的地址。
右值：⼀个表⽰数据的表达式，要么是字⾯值常量、要么是表达式求值过程中创建的临时对象等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。
值得⼀提的是，左值的英⽂简写为lvalue，右值的英⽂简写为rvalue。传统认为它们分别是left value、right value 的缩写。现代C++中，lvalue 被解释为loactor value的缩写，可意为存储在内存中、有明确存储地址可以取地址的对象，⽽ rvalue 被解释为 read value，指的是那些可以提供数据值，但是不可以寻址，例如：临时变量，字⾯量常量，存储于寄存器中的变量等，也就是说左值和右值的核⼼区别就是能否取地址。
// 左值：可以取地址
int a = 10;
int* p = &a;
*p = 1;
const int b = 1;
string s("1111111");
s[0] = '2';
cout << &a << endl;
cout << &p << endl;
cout << &(*p) << endl;
cout << (void*) &s[0] << endl;
//s[0]是char类型，&s[0]是char*类型,cout打印char*类型是按照字符串打印的，需要强转成指针类型才能打印地址
double a = 1.1, b = 2.2;
// 右值：不能取地址
10;
a + b;
fmin(a , b);
string("2222222222");
/*cout << &10 << endl;
cout << &(a + b) << endl;
cout << &(fmin(a, b)) << endl;
cout << &(string("2222222222")) << endl;*/
左值引用和右值引用
Type& r1 = x; Type&& rr1 = y;第⼀个语句就是左值引⽤，左值引⽤就是给左值取别名，第⼆个就是右值引⽤，同样的道理，右值引⽤就是给右值取别名。
int a = 10;
int* p = new int(10);
double x = 1.1, y = 2.2;
// 左值引⽤给左值取别名
int& rr1 = a;
int*& r1 = p;
// 右值引⽤给右值取别名
int&& rr2 = 10;
double&& rr3 = x+y;
string&& rr4 = string("3333333");
- 左值引⽤不能直接引⽤右值，但是
const左值引⽤可以引⽤右值 - 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤
move(左值)
// 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值
const int& r2 = 10;
const double& r3 = x+y;
const string& r4 = string("444444");
// 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值)
string s("1111111");
int&& rx1 = move(a);
int*&& rx2 = move(p);
string&& rx3 = move(s);
string&& rx4 = (string&&)s; //rx3等价于rx4
- template typename remove_reference::type&& move (T&& arg);
- move是库⾥⾯的⼀个函数模板，本质内部是进⾏强制类型转换，当然他还涉及⼀些引⽤折叠的知识。
- 需要注意的是变量表达式都是左值属性，也就意味着⼀个右值被右值引⽤绑定后，右值引⽤变量变量表达式的属性是左值
//右值引⽤变量变量表达式的属性是左值,可以使用左值引用引用右值引用
int&& rr2 = 10;
double&& rr3 = x+y;
string&& rr4 = string("3333333");
int& rr5 = rr2;
double& rr6 = rr3;
string& rr7 = rr4;
cout << &rr2 << endl;
cout << &rr3 << endl;
cout << &rr4 << endl;
- 语法层⾯看，左值引⽤和右值引⽤都是取别名，不开空间。从汇编底层的⻆度看下⾯代码中r1和rr1汇编层实现，底层都是⽤指针实现的，没什么区别。底层汇编等实现和上层语法表达的意义有时是背离的，所以不要然到⼀起去理解，互相佐证，这样反⽽是陷⼊迷途。
引用延长生命周期
右值引⽤可⽤于为临时对象延⻓⽣命周期，const 的左值引⽤也能延⻓临时对象⽣存期，但这些对象⽆法被修改。
string s1 = "test";
const string& s2 = s1 + s1;//s1+s1中间会产生临时变量，const左值引用该临时变量
//s2 = "xxx"; //const左值引用延⻓⽣存期，但是不能修改
string&& s3 = s1 + s1;
s3 = "xxx"; //右值引用延⻓⽣存期，可以修改
左值和右值的参数匹配
- C++98中，我们实现⼀个const左值引⽤作为参数的函数，那么实参传递左值和右值都可以匹配。
int f1(const int& x)
{
return 10 * x;
}
int main()
{
f1(10);//传右值
int a = 20;
f1(a);//传左值
return 0;
}
-
C++11以后，分别重载左值引⽤、const左值引⽤、右值引⽤作为形参的f函数，那么实参是左值会匹配f(左值引⽤)，实参是const左值会匹配f(const 左值引⽤)，实参是右值会匹配f(右值引⽤)。
-
右值引⽤变量在⽤于表达式时属性是左值，这个设计这⾥会感觉跟怪，下⼀⼩节我们讲右值引⽤的使⽤场景时，就能体会这样设计的价值了。
void f(int& x)
{
cout << "左值引用重载" << endl;
}
void f(const int& x)
{
cout << "const左值引用重载" << endl;
}
void f(int&& x)
{
cout << "右值引用重载" << endl;
}
int a = 10;
int b = 20;
const int c = 30;
f(a);//调用f(int& x);
f(c);//调用f(const int& x);
f(a + b);//调用f(int&& x),如果没有，则调用f(const int& x);
// 右值引⽤变量在⽤于表达式时是左值
int&& d = 10;
f(d);//调用f(int& x);
f(move(d));//调用f(int&& x);
//打印结果
左值引用重载
const左值引用重载
右值引用重载
左值引用重载
右值引用重载
右值引用和移动语义的使用场景
左值引⽤主要使⽤场景是在函数中左值引⽤传参和左值引⽤传返回值时减少拷⻉，同时还可以修改实参和修改返回对象的价值。左值引⽤已经解决⼤多数场景的拷⻉效率问题，但是有些场景不能使⽤传左值引⽤返回，如addStrings函数，C++98中的解决⽅案只能是被迫使⽤输出型参数解决。那么C++11以后这⾥可以使⽤右值引⽤做返回值解决吗？显然是不可能的，因为这⾥的本质是返回对象是⼀个局部对象，函数结束这个对象就析构销毁了，右值引⽤返回也⽆法概念对象已经析构销毁的事实。
class Solution {
public:
// 传值返回需要拷⻉
string addStrings(string num1, string num2) {
string str;
int end1 = num1.size()-1, end2 = num2.size()-1;
// 进位
int next = 0;
while(end1 >= 0 || end2 >= 0)
{
int val1 = end1 >= 0 ? num1[end1--]-'0' : 0;
int val2 = end2 >= 0 ? num2[end2--]-'0' : 0;
int ret = val1 + val2+next;
next = ret / 10;
ret = ret % 10;
str += ('0'+ret);
}
if(next == 1)
str += '1';
reverse(str.begin(), str.end());
return str;
}
};
移动构造和移动赋值
- 移动构造函数是⼀种构造函数，类似拷⻉构造函数，移动构造函数要求第⼀个参数是该类类型的引
⽤，但是不同的是要求这个参数是右值引⽤，如果还有其他参数，额外的参数必须有缺省值。 - 移动赋值是⼀个赋值运算符的重载，他跟拷⻉赋值构成函数重载，类似拷⻉赋值函数，移动赋值函
数要求第⼀个参数是该类类型的引⽤，但是不同的是要求这个参数是右值引⽤。 - 对于像string/vector这样的深拷⻉的类或者包含深拷⻉的成员变量的类，移动构造和移动赋值才有
意义，因为移动构造和移动赋值的第⼀个参数都是右值引⽤的类型，他的本质是要“窃取”引⽤的
右值对象的资源，⽽不是像拷⻉构造和拷⻉赋值那样去拷⻉资源，从提⾼效率。下⾯的string简单模拟
样例实现了移动构造和移动赋值，我们需要结合场景理解。
//这里只截取了拷贝构造，移动构造，移动赋值
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
string(const string& s)
:_str(nullptr)
{
cout << "string(const string& s) -- 拷⻉构造" << endl;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
// 移动构造
string(string&& s)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(s);
}
string& operator=(const string& s)
{
cout << "string& operator=(const string& s) -- 拷⻉赋值" <<
endl;
if (this != &s)
{
_str[0] = '\0';
_size = 0;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
return *this;
}
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动赋值" << endl;
swap(s);
return *this;
}
int main()
{
zx::string s1("111");
zx::string s2 = s1;//拷贝构造
zx::string s3 = zx::string("2222");//构造+移动构造，优化为构造
zx::string s4 = move(s1);//移动构造
return 0;
}
//打印结果
string(char* str)-构造
string(const string& s) -- 拷贝构造
string(char* str)-构造
string(string&& s) -- 移动构造
总结：没有移动构造，使用拷贝构造，需要先将string(“2222”)拷贝s3，再释放右值string(“2222”)的资源，使用移动构造，直接把要释放的资源string(“2222”)利用起来，就不需要再开辟空间，拷贝资源，释放原来的右值string(“2222”)资源。string(“2222”)作为匿名对象，生命周期只在这一行。
引用折叠
- C++中不能直接定义引⽤的引⽤如 int& && r = i; ，这样写会直接报错，通过模板或 typedef中的类型操作可以构成引⽤的引⽤。
- 通过模板或 typedef 中的类型操作可以构成引⽤的引⽤时，这时C++11给出了⼀个引⽤折叠的规则：右值引⽤的右值引⽤折叠成右值引⽤，所有其他组合均折叠成左值引⽤。
typedef int& lvalue;
typedef int&& rvalue;
int n = 10;
lvalue& rr1 = n;//rr1的类型是int&，左值引用的左值引用是左值引用
lvalue&& rr2= n;//rr2的类型是int&，左值引用的右值引用是左值引用
rvalue& rr3 = n;//rr3的类型是int&，右值引用的左值引用是左值引用
rvalue&& rr4 = move(n);// rr4的类型是int&&，左值引用的右值引用是右值引用
*下⾯的程序中很好的展⽰了模板和typedef时构成引⽤的引⽤时的引⽤折叠规则，⼤家需要⼀个⼀个仔细理解⼀下。
// 由于引⽤折叠限定，f1实例化以后总是⼀个左值引⽤
template<class T>
void f1(T& t)
{}
// 由于引⽤折叠限定，f2实例化后可以是左值引⽤，也可以是右值引⽤
template<class T>
void f2(T&& t)
{}
int main()
{
typedef int& lvalue;
typedef int&& rvalue;
int n = 10;
lvalue& rr1 = n;//rr1的类型是int&
lvalue&& rr2= n;//rr2的类型是int&
rvalue& rr3 = n;//rr3的类型是int&
rvalue&& rr4 = move(n);// rr4的类型是int&&
//没有引用折叠，实例化成void f1(int& t)
f1<int>(n);
f1<int>(0);//报错
//引用折叠，实例化成void f1(int& t)
f1<int&>(n);
f1<int&>(0);//报错
//引用折叠，实例化成void f1(int& t)
f1<int&&>(n);
f1<int&&>(0);//报错
//引用折叠，实例化成void f1(const int& t)
f1<const int&>(n);
f1<const int&>(0);
//引用折叠，实例化成void f1(const int& t)
f1<const int&&>(n);//const右值引用和右值引用的区别在于const右值引用不能修改，右值引用可以修改
f1<const int&&>(0);
//引用折叠，实例化成void f2(int& t)
f2<int&>(n);
f2<int&>(0);//报错
//引用折叠，实例化成void f2(int&& t)
f2<int&&>(n);//报错
f2<int&&>(0);
//引用折叠，实例化成void f2(const int& t)
f2<const int&>(n);
f2<const int&>(0);
//引用折叠，实例化成void f2(const int&& t)
f2<const int&&>(n);//报错
f2<const int&&>(0);
return 0;
}
- 像f2这样的函数模板中，T&& x参数看起来是右值引⽤参数，但是由于引⽤折叠的规则，他传递左值时就是左值引⽤，传递右值时就是右值引⽤，有些地⽅也把这种函数模板的参数叫做万能引⽤。
- Function(T&& t)函数模板程序中，假设实参是int右值，模板参数T的推导int，实参是int左值，模板参数T的推导int&，再结合引⽤折叠规则，就实现了实参是左值，实例化出左值引⽤版本形参的Function，实参是右值，实例化出右值引⽤版本形参的Function。
//万能引用
template<class T>
void Funciton(T&& t)
{
int a = 10;
T x = a;
//x++;
cout << &a << endl;
cout << &x << endl;
}
int main()
{
int n = 10;
//10是右值，没有引用折叠，推导T为int,实例化成void Funciton(int&& t)
Funciton(10);
//n为左值，引用折叠，推导T为int&,实例化成void Funciton(int& t)
Funciton(n);
//move(n)为右值，引用折叠，推导T为int,实例化成void Funciton(int&& t)
Funciton(move(n));
const int b = 8;
//b为左值，引用折叠，推导T为const int&,实例化成void Funciton(const int& t)
Funciton(b);
//move(b)为右值，引用折叠，推导T为const int,实例化成void Funciton(const int&& t)
Funciton(move(b)); //
}
总结：万能引用用在一些具体场景可以减少拷贝，提高效率，例如将string模式实现的拷贝构造和移动构造写成万能引用，只不过一些场景需要搭配完美转发使用。
但是引用折叠有一个问题，不管是左值引用还是右值引用，该引用表达式的属性都是左值属性，如果在万能引用里面还有函数调用，只能调用左值版本？解决该问题的方法–完美转发。
完美转发
- Function(T&& t)函数模板程序中，传左值实例化以后是左值引⽤的Function函数，传右值实例化以后是右值引⽤的Function函数。
- 但是变量表达式都是左值属性，也就意味着⼀个右值被右值引⽤绑定后，右值引⽤变量表达式的属性是左值，也就是说Function函数中t的属性是左值，那么我们把t传递给下⼀层函数Fun，那么匹配的都是左值引⽤版本的Fun函数。这⾥我们想要保持t对象的属性，就需要使⽤完美转发实现。
template <class T> T&& forward (typename remove_reference<T>::type& arg);template <class T> T&& forward (typename remove_reference<T>::type&& arg)；- 完美转发forward本质是⼀个函数模板，他主要还是通过引⽤折叠的⽅式实现，下⾯⽰例中传递给Function的实参是右值，T被推导为int，没有折叠，forward内部t被强转为右值引⽤返回；传递给Function的实参是左值，T被推导为int&，引⽤折叠为左值引⽤，forward内部t被强转为左值引⽤返回。
//不管是左值引用还是右值引用，该引用表达式的属性都是左值属性，因此，在调用Fun(t)是，会调用void Fun(int& x)，void Fun(const int& x)
//完美转发可以判断类型是否有引用，没有引用例如int，则是右值，需要将t强制转化为右值引用，有引用例如int&,则是左值，引⽤折叠为左值引⽤，forward内部t被强转为左值引⽤返回。
template<class T>
void Funciton(T&& t)
{
Fun(forward<T>(t));//forward的实现也是一个模板
//Fun(t);
}
int main()
{
int n = 10;
//10是右值，没有引用折叠，推导T为int,实例化成void Funciton(int&& t)
Funciton(10);
//n为左值，引用折叠，推导T为int&,实例化成void Funciton(int& t)
Funciton(n);
//move(n)为右值，引用折叠，推导T为int,实例化成void Funciton(int&& t)
Funciton(move(n));
const int b = 8;
//b为左值，引用折叠，推导T为const int&,实例化成void Funciton(const int& t)
Funciton(b);
//move(b)为右值，引用折叠，推导T为const int,实例化成void Funciton(const int&& t)
Funciton(move(b));
}
//打印结果Fun(t);
左值引用
左值引用
左值引用
const 左值引用
const 左值引用
//打印结果Fun(forward<T>(t));
右值引用
左值引用
右值引用
const 左值引用
const 右值引用
应用场景
template<class T>
struct list_node
{
T _data;
list_node<T>* _next;
list_node<T>* _prev;
//拷贝构造
/*list_node(const T& data = T())
:_data(data)
,_next(nullptr)
,_prev(nullptr)
{}
//移动构造
list_node(T&& data)
:_data(forward<T>(data))
, _next(nullptr)
, _prev(nullptr)
{}*/
list_node() = default;
//万能引用
template<class X>
list_node(X&& data)
:_data(forward<X>(data))
, _next(nullptr)
, _prev(nullptr)
{}
};
惟楚有才，于斯为盛。欢迎来到长沙！！！ 茶颜悦色、臭豆腐、CSDN和你一个都不能少~
更多推荐
12
0- 0
已为社区贡献1条内容
所有评论(0)