左值和右值
左值和右值
按字面意思，通俗地说。以赋值符号 = 为界，= 左边的就是左值，= 右边就是右值。
更深一层，可以将 L-value 的 L, 理解成 Location，表示定位，地址。将 R-value 的 R 理解成 Read，表示读取数据。
左值右值判断技巧： 如果在表达式的下一行可以用单一变量表示输出结果，则为左值。否则该表达式的值存储在临时匿名内存中，则为右值。 左值持久，右值短暂
-
T &代表左值引用，可以绑定到左值上。 -
T &&代表右值引用，可以绑定到右值上。
有BUG版：
void judge2(int &val) {
cout << "[judge2 left value] ";
return ;
}
void judge2(int &&val) {
cout << "[judge2 right value] ";
return ;
}
void judge1(int &val) {
cout << "[judge1 left value] ";
judge2(val); //val此时是个常态，所以一定是左值
return ;
}
void judge1(int &&val) {
cout << "[judge1 right value] ";
judge2(val); //val此时是个常态，所以一定是左值
return ;
}
#define TEST(x) { \
judge1(x); \
printf(" %7s %d\n", #x, x); \
}
int main() {
int x = 1, y = 2;
printf("x = %d, y = %d\n", x, y);
TEST(x);
TEST(x + y);
TEST(x + 1);
TEST(x += 1);
TEST(++x);
TEST(x++);
return 0;
}
x = 1, y = 2
[judge1 left value] [judge2 left value] x 1
[judge1 right value] [judge2 left value] x + y 3
[judge1 right value] [judge2 left value] x + 1 2
[judge1 left value] [judge2 left value] x += 1 3
[judge1 left value] [judge2 left value] ++x 5
[judge1 right value] [judge2 left value] x++ 6
无BUG版：
move() 和 forward<type>()主要解决引用函数参数为右值时，传进来之后有了对象就变成了左值。
void judge2(int &val) {
cout << "[judge2 left value] ";
return ;
}
void judge2(int &&val) {
cout << "[judge2 right value] ";
return ;
}
void judge1(int &val) {
cout << "[judge1 left value] ";
//judge2(val);
judge2(forward<int &>(val));
return ;
}
void judge1(int &&val) {
cout << "[judge1 right value] ";
//judge2(move(val)); //move可以强制转换成右值
judge2(forward<int &&>(val)); //forward一种通用方式
return ;
}
#define TEST(x) { \
judge1(x); \
printf(" %7s %d\n", #x, x); \
}
int main() {
int x = 1, y = 2;
printf("x = %d, y = %d\n", x, y);
TEST(x);
TEST(x + y);
TEST(x + 1);
TEST(x += 1);
TEST(++x);
TEST(x++);
return 0;
}
x = 1, y = 2
[judge1 left value] [judge2 left value] x 1
[judge1 right value] [judge2 right value] x + y 3
[judge1 right value] [judge2 right value] x + 1 2
[judge1 left value] [judge2 left value] x += 1 3
[judge1 left value] [judge2 left value] ++x 5
[judge1 right value] [judge2 right value] x++ 6
const类型的引用
- 如果引入const类型的引用，那么一个值可以与多个重载的函数参数绑定时，要注意优先级。
class A {};
void func(A &obj) {
cout << "left value" << endl;
return ;
}
void func(const A &obj) {
cout << "const left value" << endl;
return ;
}
int main() {
A a;
func(a); // 优先找左值引用做参数的函数。没有找到退而求其次找const左值引用做参数的函数。
return 0;
}
class A {};
void func(const A &obj) {
cout << "const left value" << endl;
return ;
}
void func(A &&obj) {
cout << "right value" << endl;
return ;
}
void func(const A &&obj) {
cout << "const right value" << endl;
return ;
}
int main() {
func(A());
return 0;
}
class A {};
void func(const A &obj) {
cout << "const left value" << endl;
return ;
}
void func(A &&obj) {
cout << "right value" << endl;
return ;
}
void func(const A &&obj) {
cout << "const right value" << endl;
return ;
}
int main() {
const A a;
func(move(a)); // 优先绑定const右值引用，没有找const左值引用。即使有右值引用也绑定不上，因为实参为const类型
return 0;
}
-
注意：函数的形式参数为const类型引用可以触发重载，但是const类型的值不可以触发重载。
个人理解这种传值情况，无论形参是否为const都不会影响形参的值，所以无意义。而传地址(引用)时，const限定则有实意。
// 不能触发重载
void func(const int a) {
return ;
}
void func(int a) {
return ;
}
移动构造函数
所谓移动语义，指的就是以移动而非深拷贝的方式初始化含有指针成员的类对象。简单的理解，移动语义指的就是将其他对象（通常是临时对象）拥有的内存资源 “移为已用”。
事实上，对于程序执行过程中产生的临时对象，往往只用于传递数据（没有其它的用处），并且会很快会被销毁。因此在使用临时对象初始化新对象时，我们可以将其包含的指针成员指向的内存资源直接移给新对象所有，无需再新拷贝一份，这大大提高了初始化的执行效率。
故事分析：
-
对于深拷贝来说犹如一个师傅从小培养一个徒弟，在几十年的时间里，师傅一点一点教，徒弟一点一点学，最后徒弟学会了师傅所有东西，变得和师傅一样强。
-
对于移动构造来说，师傅在濒危时候才收一个徒弟，这时候师傅用传功的方式瞬间把必胜绝学都传给了徒弟，而师傅散功而死。
我们知道，非 const 右值引用只能操作右值，程序执行结果中产生的临时对象（例如函数返回值、lambda 表达式等）既无名称也无法获取其存储地址，所以属于右值。当类中同时包含拷贝构造函数和移动构造函数时，如果使用临时对象初始化当前类的对象，编译器会优先调用移动构造函数来完成此操作。只有当类中没有合适的移动构造函数时，编译器才会退而求其次，调用拷贝构造函数。
在实际开发中，通常在类中自定义移动构造函数的同时，会再为其自定义一个适当的拷贝构造函数，由此当用户利用右值初始化类对象时，会调用移动构造函数；使用左值（非右值）初始化类对象时，会调用拷贝构造函数。
Q：如果使用左值初始化同类对象，但也想调用移动构造函数完成，有没有办法可以实现呢？
A：默认情况下，左值初始化同类对象只能通过拷贝构造函数完成，如果想调用移动构造函数，则必须使用右值进行初始化。C++11 标准中为了满足用户使用左值初始化同类对象时也通过移动构造函数完成的需求，新引入了 std::move() 函数，它可以将左值强制转换成对应的右值，由此便可以使用移动构造函数。
class A {
public:
A() : data(new int[5]), __size(5) {
//1, 2, 3, 4, 5
for (int i = 1; i <= __size; ++i) data[i - 1] = i;
cout << this << " default constructor" << endl;
}
A(const A &obj) : data(new int[5]), __size(5) {
for (int i = 0; i < __size; ++i) data[i] = obj.data[i];
cout << this << " deep_copy constructor" << endl;
}
A(A &&obj) : __size(5) { //Cannot be const, because const object is read-only
data = obj.data;
obj.data = nullptr;
obj.__size = 0;
cout << this << " move constructor" << endl;
}
A& operator++() {
for (int i = 0; i < __size; ++i) ++data[i];
return *this;
}
A operator++(int) {
A obj(*this);
for (int i = 0; i < __size; ++i) ++data[i];
return obj;
}
void show() {
if (data == nullptr) {
cout << "NULL" << endl;
return ;
}
for (int i = 0; i < __size; ++i) {
cout << data[i] << " ";
}
cout << endl;
return ;
}
virtual ~A() {
delete data;
cout << this << " deconstructor" << endl;
}
private:
int *data, __size;
};
int main() {
cout << "A a ----------------------------------BEGIN" << endl;
A a;
cout << "a : "; a.show();
cout << "A b(++a) -----------------------------BEGIN" << endl;
A b(++a);
cout << "a : "; a.show();
cout << "b : "; b.show();
cout << "A c(a++) -----------------------------BEGIN" << endl;
A c(a++);
cout << "a : "; a.show();
cout << "c : "; c.show();
cout << "A d(move(a)) -----------------------------BEGIN" << endl;
A d(move(a));
cout << "a : "; a.show();
cout << "d : "; d.show();
return 0;
}
现在的编辑器会自动优化(RVO)。假如想体现出效果，记得编译时加参数 -fno-elide-constructors
其作用为 return x 时 （x为对象）减小开销，直接把该片内存的管理权(this指针)给目标对象。
A a ----------------------------------BEGIN
0x7fffdbe89260 default constructor
a : 1 2 3 4 5
A b(++a) -----------------------------BEGIN
0x7fffdbe89280 deep_copy constructor
a : 2 3 4 5 6
b : 2 3 4 5 6
A c(a++) -----------------------------BEGIN
0x7fffdbe89220 deep_copy constructor
0x7fffdbe892c0 move constructor
0x7fffdbe89220 deconstructor
0x7fffdbe892a0 move constructor
0x7fffdbe892c0 deconstructor
a : 3 4 5 6 7
c : 2 3 4 5 6
A d(move(a)) -----------------------------BEGIN
0x7fffdbe892c0 move constructor
a : NULL
d : 3 4 5 6 7
0x7fffdbe892c0 deconstructor
0x7fffdbe892a0 deconstructor
0x7fffdbe89280 deconstructor
0x7fffdbe89260 deconstructor