代码拉取完成，页面将自动刷新
C++11 rvalues and move semantics confusion (return statement) - Stack Overflow
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&& 就不再是右值引用类型，而是未定引用类型
& 取地址的就是左值
int foo; // foo 是一个左值
cout << &foo; // 可以被取地址
foo = foo + 5; // foo + 5 是一个左值
cout << &(foo+5); // err
cout << &1; // err
cout << &'a'; // err: lvalue required as unary '&' operand
cout << &"abc"; // OK, 可以对字符串取地址
"abc" = "cba"; // err: assignment of read-only location
为什么字符串字面量是对象？——节省内存，同一份字符串字面量引用的是同一块内存
int i = 5; // int 型字面量
auto f = []{return 5;}; // lambda 表达式
T&& && 变成 T&&）T& &, T& &&, T&& & 都变成 T&）typedef int & lRef;
typedef int && rRef;
typedef const int & lcRef;
typedef const int && rcRef;
int main() {
int a = 10;
// 左值引用
lRef b = a; // T&
lRef & c = a; // T& &
lRef && d = a; // T& &&
rRef & e = a; // T&& &
// 右值引用
rRef f = 10; // T&&
rRef && g = 10; // T&& &&
// 左值引用
lcRef b2 = a; // const T&
lcRef & c2 = a; // const T& &
lcRef && d2 = a; // const T& &&
rcRef & e2 = a; // const T&& &
// 右值引用
rcRef f2 = 10; // const T&&
rcRef && g2 = 10; // const T&& &&
return 0;
}
move() 与 forward()
move() 的主要作用是将一个左值转为 xvalue（右值）, 其实现本质上是一个 static_cast<T>
forward() 主要用于实现完美转发，其作用是将一个类型为（左值/右值）引用的左值，转化为它的类型所对应的值类型（左值/右值）
觉得难以理解的话，就继续看下去吧
-> 右值的转换可看做“读取对象的值”（reading the value of an object）C++11 开始，表达式一般分为三类：左值（lvalue）、消亡值（xvalue）和纯右值（prvalue）；
其中左值和消亡值统称泛左值（glvalue）；
消亡值和纯右值统称右值（rvalue）。
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 在发生自动类型推断时，是未定的引用类型
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
T&& 才是未定引用类型
void bar(int&& v) { } // 非模板编程，int&& 是明确的右值引用类型
bar(10); // OK: 右值引用类型 v 绑定了一个右值
int x = 10;
bar(x); // err: 右值引用类型 v 不能绑定一个左值
const A& a = getA(); // OK: 常量左值引用可以接受右值
A& a = getA(); // err: 非常量左值引用只能接受左值
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 aa = getA(); // 第二次构造：把 a 复制给一个临时变量，
// 第三次构造：把临时变量复制给 aa
// 开启优化后，相当于直接把 a “改名”成 aa 了，所以只有一次构造
return 0;
}
construct: 1 // 第一次构造，getA() 中的局部变量 a
copy construct: 1 // 第二次构造，将 a 复制给一个临时变量
destruct: 1 // 析构局部变量 a
copy construct: 2 // 第三次构造，将临时变量复制给 aa
destruct: 2 // 析构临时变量
destruct: 3 // 程序结束，析构变量 aa
construct: 1 // 构造局部变量 a，在编译的优化下，相当于直接将 a “改名” aa
destruct: 1 // 程序结束，析构变量 aa
所谓指针悬挂，指的是两个对象内部的成员指针变量指向了同一块地址，析构时这块内存会因被删除两次而发生错误
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;
}
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;
}
construct
1
copy construct
1
2
1
move construct
3
3
{
list<string> tokens;
//省略初始化...
list<string> t = tokens; // 这里存在深拷贝
}
list<string> tokens;
list<string> t = move(tokens); // 这里没有深拷贝
move() 的本质move() 实际上并没有移动任何东西，它唯一的功能是将一个左值强制转换为一个右值引用move() 仍会发生深拷贝，比如基本类型，定长数组等move() 对于含有资源（堆内存或句柄）的对象来说更有意义。move() 的原型 TODOvoid processValue(int& a) { cout << "lvalue" << endl; }
void processValue(int&& a) { cout << "rvalue" << endl; }
template <typename T>
void forwardValue(T&& val) {
processValue(val); // 因为 val 本身是一个左值
// 所以无论 val 是左值引用类型还是右值引用类型的变量
// 都只会调用 processValue(int& a)
}
int main() {
int i = 1;
forwardValue(i); // 传入一个左值
// val 会被推断为是一个左值引用类型
forwardValue(1); // 传入一个右值
// 虽然 val 会被推断为是一个右值引用类型，但它本身是一个左值
return 0;
}
lvalue
lvalue
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;
}
lvalue
rvalue
forward<T>()的原型 TODO此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。