C++中的左值与右值
说明
Index
小结
左值引用类型 与 右值引用类型
T t1; // 类型 T
T& t2 = t1; // T& 表示 T 的左值引用类型,t2 是左值引用类型的变量,它引用的是一个左值
T&& t3 = T(); // T&& 表示 T 的右值引用类型,t3 是右值引用类型的变量,它引用的是一个右值
T& t4 = T(); // err: 左值引用 不能绑定一个 右值
T&& t5 = t1; // err: 右值引用 不能绑定一个 左值
const T& t6 = t1; // const T& 表示 T 的常量(左值)引用
const T& t7 = T(); // 常量引用类型是“万能”的引用类型
// 不能把 常量类型 绑定到 非常量引用类型 上
T&& t8 = t6; // err: 不能把常量类型绑定到 右值引用类型
T& t9 = t6; // err: 也不能把常量类型绑定到 左值引用类型
这里的变量 t1~t9 都是左值,因为它们都有名字
当发生自动类型推断时,T&&
也能绑定左值
template<typename T> // 模板元编程
void foo(T&& t) { } // 此时 T&& 不是右值引用类型,而是未定引用类型
void bar(int&& v) { } // 非模板编程,int&& 是明确的右值引用类型
foo(10); // OK: 未定引用类型 t 绑定了一个右值
bar(10); // OK: 右值引用类型 v 绑定了一个右值
int x = 10;
foo(x); // OK: 未定引用类型 t 绑定了一个左值
bar(x); // err: 右值引用类型 v 不能绑定一个左值
int&& p = x; // err
auto&& t = x; // OK
- 此时,
T&&
就不再是右值引用类型,而是未定引用类型
如何快速判断左值与右值
引用折叠规则
- 所有的右值引用叠加到右值引用上仍然还是一个右值引用。(
T&& && 变成 T&&
)
- 所有的其他引用类型之间的叠加都将变成左值引用。 (
T& &, T& &&, T&& & 都变成 T&
)
- 对常量引用规则一致
move()
与 forward()
-
move()
的主要作用是将一个左值转为 xvalue(右值), 其实现本质上是一个 static_cast<T>
-
forward()
主要用于实现完美转发,其作用是将一个类型为(左值/右值)引用的左值,转化为它的类型所对应的值类型(左值/右值)
觉得难以理解的话,就继续看下去吧
左值与右值的本质
- 左值表示是“对象”(object),右值表示“值”(value)——“对象”内存储着“值”
- 左值
->
右值的转换可看做“读取对象的值”(reading the value of an object)
- 其他说法:
- 左值是可以作为内存单元地址的值;右值是可以作为内存单元内容的值
- 左值是内存中持续存储数据的一个地址;右值是临时表达式结果
左值、消亡值、纯右值
右值引用的特点
右值引用延长了临时对象的生命周期
int i = getI(); // getI() 会返回一个 int 型的临时变量
T&& t = getT(); // t 是一个右值引用
// getT() 同样返回一个临时变量,但是该临时变量被“引用”了
// 因此生命周期得到了延长
-
getI()
和 getT()
都返回一个临时变量,但是 getT()
产生的临时变量不会在表达式结束后就马上销毁,而是会被“续命”——它的声明周期将和它的引用类型变量 t
一样长。
利用右值引用避免临时对象的拷贝和析构
int g_constructCount=0;
int g_copyConstructCount=0;
int g_destructCount=0;
struct A {
A(){ // 基本构造
cout<<"construct: "<<++g_constructCount<<endl;
}
A(const A& a) { // 拷贝构造
cout<<"copy construct: "<<++g_copyConstructCount <<endl;
}
~A() { // 析构
cout<<"destruct: "<<++g_destructCount<<endl;
}
};
A getA() {
A a; // 第一次构造
return a;
// return A(); // 等价,分开写是为了便于说明
}
int main() {
A a2 = getA(); // 非右值引用
A&& a3 = getA(); // 右值引用
return 0;
}
- 非右值引用,关闭返回值优化
construct: 1 // 第一次构造,getA() 中的局部变量 a
copy construct: 1 // 第二次构造,将 a 复制给一个临时变量
destruct: 1 // 析构局部变量 a
copy construct: 2 // 第三次构造,将临时变量复制给 a2
destruct: 2 // 析构临时变量
destruct: 3 // 程序结束,析构变量 a2
- 右值引用,关闭返回值优化
construct: 1 // 第一次构造,getA() 中的局部变量 a
copy construct: 1 // 第二次构造,将 a 复制给一个临时变量
// 右值引用 a3 延长了临时变量的声明周期,使其没有马上被析构
destruct: 1 // 析构局部变量 a
destruct: 2 // 程序结束,析构变量 a3
利用常量引用也能避免临时对象的拷贝与析构 -> 常量(左值)引用
返回值优化做的更彻底 -> 返回值优化 RVO
右值引用类型绑定的一定是右值,但 T&&
可能不是右值引用类型
int&& v1 = 1; // OK: v1 是右值引用类型,且 1 是右值
int&& v2 = v1; // err: v2 是右值引用类型,但 v1 是左值
当发生自动类型推断时,T&&
是未定的引用类型
-
T&& t
在发生自动类型推断时,是未定的引用类型
- 比如模板元编程,auto 关键字等
- 如果
t
被一个左值初始化,它就是一个左值;如果 t
被一个右值初始化,它就是一个右值
template<typename T> // 模板元编程
void foo(T&& t) { } // 此时 T&& 不是右值引用类型,而是未定引用类型
foo(10); // OK: 未定引用类型 t 绑定了一个右值
int x = 10;
foo(x); // OK: 未定引用类型 t 绑定了一个左值
int&& p = x; // err
auto&& t = x; // OK
- 仅当发生自动类型推导时(模板编程,auto 关键字),
T&&
才是未定引用类型void bar(int&& v) { } // 非模板编程,int&& 是明确的右值引用类型
bar(10); // OK: 右值引用类型 v 绑定了一个右值
int x = 10;
bar(x); // err: 右值引用类型 v 不能绑定一个左值
常量(左值)引用
返回值优化 RVO
移动语义
深拷贝带来的问题
- 带有堆内存的类,必须提供一个深拷贝构造函数,以避免“指针悬挂”问题
所谓指针悬挂,指的是两个对象内部的成员指针变量指向了同一块地址,析构时这块内存会因被删除两次而发生错误
class A {
public:
A(): m_ptr(new int(0)) { // new 堆内存
cout << "construct" << endl;
}
A(const A& a):m_ptr(new int(*a.m_ptr)) { // 深拷贝构造函数
cout << "copy construct" << endl;
}
~A(){
// cout << "destruct" << endl;
delete m_ptr; // 析构函数,释放堆内存的资源
}
private:
int* m_ptr; // 成员指针变量
};
A getA() {
return A();
}
int main() {
A a = getA();
return 0;
}
- 输出(关闭 RVO)
construct
copy construct
copy construct
如果不关闭 RVO,只会输出 construct
- 提供深拷贝能够保证程序的正确性,但会带来额外的性能损耗——临时对象也会申请一块内存,然后又马上被销毁了;如果堆内存很大的话,这个性能损耗是不可忽略的
- 对于临时对象而言,深拷贝不是必须的
- 利用右值引用可以避免无谓的深拷贝——移动拷贝构造函数
移动构造函数
- 相比上面的代码,这里只多了一个移动构造函数——一般会同时提供拷贝构造与移动构造
class A {
public:
A(): m_ptr(new int(0)) { // new 堆内存
cout << "construct" << endl;
}
A(const A& a): m_ptr(new int(*a.m_ptr)) { // 深拷贝构造函数
cout << "copy construct" << endl;
}
A(A&& a): m_ptr(a.m_ptr) { // 移动构造函数
a.m_ptr = nullptr; // 把参数对象的指针指向 nullptr
cout << "move construct" << endl;
}
~A(){
// cout << "destruct" << endl;
delete m_ptr; // 析构函数,释放堆内存的资源
}
private:
int* m_ptr; // 成员指针变量
};
A getA() {
return A();
}
int main() {
A a = getA();
return 0;
}
- 输出(关闭返回值优化)
construct
move construct // 没有调用深拷贝,值调用了移动构造函数
move construct
如果不关闭 RVO,只会输出 construct
- 这里没有自动类型推断,所以
A&&
一定是右值引用类型,因此所有临时对象(右值)会匹配到这个构造函数,而不会调用深拷贝
- 对于临时对象而言,没有必要调用深拷贝
- 这就是所谓的移动语义——右值引用的一个重要目的就是为了支持移动语义
移动语义 与 move()
- 移动语义是通过右值引用来匹配临时值,从而避免深拷贝
- 利用
move()
方法,可以将普通的左值转化为右值来达到避免深拷贝的目的class A {
public:
A(): m_ptr(new int(0)) { // new 堆内存
cout << "construct" << endl;
}
A(const A& a): m_ptr(new int(*a.m_ptr)) { // 深拷贝构造函数
cout << "copy construct" << endl;
}
A(A&& a): m_ptr(a.m_ptr) { // 移动构造函数
//a.m_ptr = nullptr; // 为了实验,这里没有把参数对象的指针指向 nullptr
cout << "move construct" << endl;
}
~A(){
// cout << "destruct" << endl;
delete m_ptr; // 析构函数,释放堆内存的资源
}
int get_data() {
return *m_ptr;
}
void set_data(int v) {
*m_ptr = v;
}
private:
int* m_ptr; // 成员指针变量
};
int main() {
A a1; // construct
a1.set_data(1);
cout << a1.get_data() << endl; // 1
A a2 = a1; // copy construct
cout << a2.get_data() << endl; // 1
a2.set_data(2);
cout << a2.get_data() << endl; // 2
cout << a1.get_data() << endl; // 1
A a3 = move(a1); // move construct
a3.set_data(3);
cout << a3.get_data() << endl; // 3
cout << a1.get_data() << endl; // 3: 因为没有深拷贝,指向的是同一块地址
return 0;
}
- STL 容器的移动语义
{
list<string> tokens;
//省略初始化...
list<string> t = tokens; // 这里存在深拷贝
}
list<string> tokens;
list<string> t = move(tokens); // 这里没有深拷贝
move()
的本质
-
move()
实际上并没有移动任何东西,它唯一的功能是将一个左值强制转换为一个右值引用
- 如果没有对应的移动构造函数,那么使用
move()
仍会发生深拷贝,比如基本类型,定长数组等
- 因此,
move()
对于含有资源(堆内存或句柄)的对象来说更有意义。
move()
的原型 TODO
c++11 中的 move 与 forward - twoon - 博客园
完美转发
forward<T>()
实现完美转发
这里写的不够详细,有时间在整理
-
在函数模板中,T&&
实际上是未定引用类型,它是可以得知传入的对象是左值还是右值的
-
这个特性使其可以成为一个参数的路由,利用 forward()
实现完美转发
-
std::forward<T>()
可以保留表达式作为“对象”(左值)或“值”(右值)的特性
-
利用 std::forward<T>()
实现完美转发:
不可以用变量接收 forward<T>()
的返回值,因为所有具名变量都是左值
void processValue(int& a) { cout << "lvalue" << endl; }
void processValue(int&& a) { cout << "rvalue" << endl; }
template <typename T>
void forwardValue(T&& val) {
processValue(forward<T>(val)); // 利用 forward 保持对象的左右值特性
// 必须把 forward<T>(val) 打包作为参数,否则都达不到完美转发的目的
// auto v = forward<T>(val);
// processValue(v);
// auto&& v = forward<T>(val);
// processValue(v);
}
int main() {
int i = 1;
forwardValue(i); // 传入一个左值
forwardValue(1); // 传入一个右值
return 0;
}
forward<T>()
的原型 TODO
Reference