左值、右值、左值引用、右值引用及移动构造函数

左值

左值是一个表示数据的表达式，它代表一个具名的内存位置，程序可以获取其地址，可以通过地址访问它们，是可被引用的数据对象

右值

每个表达式不是左值就是右值。 右值代表一个临时的值，不能被取地址，不能被修改，是不能出现在赋值语句的左边的

int foo() {
	return 1;
}
 
void test01() {
	int a = 1;
    int b = 2;
	int c = a + b;
	int d = foo();
};

比如上面的a,b,c,d这几个变量都是左值，但是a+b和foo()都是右值。

左值引用

左值引用也就是传统的C++引用，通过&符号来声明，它可以使得标识符关联到左值。引用是已定义变量的别名，例如下面将b作为a变量的别名，b和a指向相同的值和内存单元

	int a = 1;
    int& b = a;

引用的主要用途是用来作为函数的形参，通过将引用变量用作参数，函数将使用原始数据，而不是其副本。

右值引用

在C++11引入了右值引用（rvalue reference）的概念，通过&&符号来声明，右值引用可以关联到右值。

	int && a = 1;
	cout << "a = " << a << ", " << &a<< endl;

引入右值引用的目的是什么呢？其主要目的之一是实现移动语义。

移动语义是一种优化技术，它允在对象之间转移资源的所有权，而不是进行资源的复制或者拷贝。移动语义这种技术正是通过使用右值引用来实现的。

先说一下为什么会诞生移动语义这个东西：当调用拷贝构造函数或赋值运算符时会对对象进行拷贝操作，也就是会申请一块新的内存空间，然后把数据复制到新的内存空间当中，但是这对于大型对象来说工作量是很大的，当然在一些情况下这是必要的操作，但是在某些场景下，可能其实不用额外拷贝一份，只需要将对象的资源所有权从一个对象转移到另一个对象就可以满足要求了。

基于移动语义，也就有了移动构造函数

移动构造函数

移动构造函数(move constructor)，是C++11标准增加的在创建对象时移动旧对象资源的构造函数。

类的移动构造函数原型通常是这样的：类名(类类型 &&);。以CDate类为例，其移动构造函数声明如下：

CDate(CDate &&date);

移动构造函数的几个特点：
1、函数名和类名相同，没有返回值，因为它也是构造函数的一种；
2、第一个参数必须是一个自身类类型的右值引用(&&)，且其他参数都有默认值。
3、第一个参数不能声明为 const 右值引用的原因是该引用在函数内会被修改(移动资源)。
4、移动构造函数执行后，需要保证右值引用的对象能够被正常销毁。

下面看看怎样声明定义自己的移动构造函数：

CDate(CDate &&date) noexcept;	// 声明
CDate::CDate(CDate&& date) noexcept // 实现
{
	m_year = date.m_year;
	m_mon = date.m_mon;
	m_day = date.m_day;
	str = date.str;
	date.str = NULL;
	cout << "Calling Move Constructor" << ", this=" << this <<endl;
}

移动构造函数解析：

1、处理普通数据成员，直接使用旧对象的进行赋值；
2、处理指向堆内存的指针，直接堆内存地址给新对象的指针，旧对象指针指向NULL。
语句str = date.str;将旧对象的str直接给到正在创建的对象，而不重新new、复制。
语句date.str = NULL;将旧对象的str赋值为NULL，保证其可以被正常销毁，delete NULL;、delete[] NULL不会造成任何问题。
3、由于移动操作“ 窃取” 资源， 它通常不分配任何资源。 因此， 移动操作通常不会抛出任何异常。不抛出异常的函数应该使用 noexcept 通知标准库，避免编译器为了处理异常而作一些额外的工作。

使用移动构造函数

1、使用移动构造函数就需要弄清楚移动构造函数是什么时候会被调用的？
如果使用一个右值(即将被销毁的对象)去初始化同类型的对象，就会调用该类的移动构造函数。

2、怎样的类需要定义移动构造函数？
如果该类的成员存在指针指向new分配的堆内存，则可以跟进需要定义移动构造函数。

3、什么时候编译器会提供默认移动构造函数？
如果该类没有定义拷贝构造函数，且没有定义移动构造函数，则编译器会提供一个 默认的移动构造函数。
如果该类定义了拷贝构造函数，则编译器不会提供 默认的移动构造函数，需要用到移动构造的地方都会调用拷贝构造函数。
如果该类定义了移动构造函数，则编译器不会提供 默认的拷贝构造函数，需要用到拷贝构造的时候，编译器会报错。

4、默认的移动构造函数做了什么工作？
默认的移动构造函数 所做的工作与默认拷贝构造函数的工作一样，执行逐成员初始化并复制内置类型。如果成员是类对象，将使用相应类的构造函数和赋值运算符，就像参数为右值一样。

下面是第一小节的代码，加了移动构造函数后的例子：

// g++ 14_Move_Constructor_Date.cpp -std=c++11
#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

#define MAX_NEW_MEM		(64*1000*1000)

class CDate
{
public:
	CDate(int year, int mon, int day);	// 构造函数声明
	CDate(const CDate& date);			// 拷贝构造函数声明
	CDate(CDate&& date) noexcept;		// 移动构造函数声明
	~CDate();							// 析构函数声明
	
	CDate operator+(int day);			// 加号运算符声明

	void show()
	{
		cout << "Date: " << m_year << "." << m_mon << "." << m_day << ", this=" << this << endl;
		//cout << "Date: " << str << endl;
	}

private:
	int m_year;
	int m_mon;
	int m_day;
	char *str;
};

// 构造函数定义
CDate::CDate(int year, int mon, int day)
{
	m_year = year;
	m_mon = mon;
	m_day = day;
	str = new char[MAX_NEW_MEM];
	sprintf(str, "%4d.%02d.%02d", year,mon,day);
	cout << "Calling Constructor" << ", this=" << this <<endl;
}

// 拷贝构造函数定义
CDate::CDate(const CDate& date)
{
	m_year = date.m_year;
	m_mon = date.m_mon;
	m_day = date.m_day;
	str = new char[MAX_NEW_MEM];
	memcpy(str, date.str, MAX_NEW_MEM);
	cout << "Calling Copy Constructor" << ", this=" << this << ", Copy Data" <<endl;
}

CDate::CDate(CDate&& date) noexcept
{
	m_year = date.m_year;
	m_mon = date.m_mon;
	m_day = date.m_day;
	str = date.str;
	date.str = NULL;
	cout << "Calling Move Constructor" << ", this=" << this <<endl;
}

// 析构函数定义
CDate::~CDate()
{
	cout << "Calling Destructor" << ", this=" << this <<endl;
	delete [] str;
}

CDate CDate::operator+(int day)
{
	CDate temp = *this;
	temp.m_day += day;
	cout << "Calling operator+" << ", this=" << &temp << endl;
	return temp;
}

int main()
{
	CDate date(2024,06,07);
	cout << endl;
	
	CDate date1 = std::move(date+1);// 调用移动构造函数,std::move 强制将 date+1 的求值结果转为右值
	date1.show();
	
	cout << endl;
	
	return 0;
}

移动构造函数的目的就是为了减少一次拷贝，提升性能。C++11主要通过右值引用来实现移动语义，在使用右值(即将销毁的对象)去创建对象时，调用移动构造函数而不调用拷贝构造函数，以此减少一次拷贝。

std::move()会强制转为右值

调用移动构造和拷贝构造的例子

#include <iostream>
#include <string>

class MyString {
public:
    MyString() : str(nullptr), len(0) {}

    MyString(const char* s) : str(nullptr), len(0) {
        if (s != nullptr) {
            len = strlen(s);
            str = new char[len + 1];
            strcpy(str, s);
        }
    }

    // 拷贝构造函数
    MyString(const MyString& other) : str(nullptr), len(0) {
        if (other.str != nullptr) {
            len = other.len;
            str = new char[len + 1];
            strcpy(str, other.str);
        }
    }

    // 移动构造函数
    MyString(MyString&& other) noexcept {
        str = other.str;
        len = other.len;
        other.str = nullptr;
        other.len = 0;
    }

    ~MyString() {
        if (str != nullptr) {
            delete[] str;
            str = nullptr;
            len = 0;
        }
    }

private:
    char* str;
    size_t len;
};

int main() {
    MyString s1("Hello");  // 调用构造函数
    MyString s2(s1);      // 调用拷贝构造函数
    MyString s3(std::move(s1));  // 调用移动构造函数
    return 0;
}

参考：

1. 左值、右值、左值引用和右值引用：C++中的左值和右值_c++左值和右值-优快云博客
2. 移动构造函数：【C++ | 移动构造函数】C++11的 移动构造函数 详解及例子代码-优快云博客
3. 调用移动构造和拷贝构造的例子：C++中的移动构造函数和拷贝构造函数的区别 - Dijkstra·Liu - 博客园