从C到C++理解右值引用和移动语义的过程解析

typedef struct {
    int number;
    char *msg;
} Data;
Data create_data() {
    Data d;
    d.msg = malloc(100);
    strcpy(d.msg, "Hello");
    return d;  // 返回结构体会发生内存拷贝
}
void process_data(Data d) {
    // 处理数据，但这里会发生一次拷贝
}
int main() {
    Data d = create_data();  // 一次拷贝
    process_data(d);         // 又一次拷贝
    free(d.msg);
    return 0;
}

int a = 10;        // a是左值
int* p = &a;       // 可以取地址

100;               // 字面量，右值
a + 5;             // 表达式结果，右值
get_data();        // 函数返回的临时对象，右值

int a = 10;
int &ref = a;        // 左值引用，类似于 int* const ref = &a;
ref = 20;            // 直接修改a的值，不需要解引用
// C语言等效代码
int a = 10;
int* const ref = &a;  // 常量指针
*ref = 20;            // 需要解引用

Data create_data() {
    Data d;
    // ... 初始化d
    return d;  // 返回临时对象
}
Data my_data = create_data();  // 这里会发生什么？

int a = 10;
int &lref = a;        // 左值引用：只能绑定左值
int &&rref = 100;     // 右值引用：只能绑定右值
// 错误示例
// int &&rref2 = a;     // 错误！不能绑定左值
// int &lref2 = 100;    // 错误！不能绑定右值

// 近似等效的C代码
int anonymous_variable = 100;  // 编译器创建的匿名变量
int* const rref = &anonymous_variable;  // 右值引用近似于此

class Data {
    char* msg;
public:
    Data() { msg = new char[100]; }
    ~Data() { delete[] msg; }
    // 拷贝构造函数（深拷贝）
    Data(const Data& other) {
        msg = new char[100];
        memcpy(msg, other.msg, 100);  // 内存拷贝，开销大！
    }
};

class Data {
    char* msg;
public:
    // 移动构造函数
    Data(Data&& other) {  // Data&& 表示接受右值引用
        msg = other.msg;   // 直接接管指针
        other.msg = nullptr;  // 原对象放弃所有权
        // 没有内存拷贝！只有指针赋值
    }
};

// C语言中的"移动"模拟
Data move_data(Data* src) {
    Data dest;
    dest.msg = src->msg;  // 指针转移，不拷贝内容
    src->msg = NULL;      // 原指针置空
    return dest;
}

#include <iostream>
#include <cstring>
using namespace std;
class Data {
    char* msg;
    int number;
public:
    // 构造函数
    Data(int num = 0, const char* text = "默认") {
        cout << "构造函数" << endl;
        msg = new char[100];
        strcpy(msg, text);
        number = num;
    }
    // 析构函数
    ~Data() {
        cout << "析构函数";
        if(msg) {
            cout << ": 释放 " << msg << endl;
            delete[] msg;
        } else {
            cout << ": 无需释放（已移动）" << endl;
        }
    }
    // 拷贝构造函数（深拷贝）
    Data(const Data& other) {
        cout << "拷贝构造函数（深拷贝）" << endl;
        msg = new char[100];
        strcpy(msg, other.msg);
        number = other.number;
    }
    // 移动构造函数（高效转移）
    Data(Data&& other) {
        cout << "移动构造函数（资源转移）" << endl;
        msg = other.msg;      // 接管资源
        other.msg = nullptr;  // 原对象放弃所有权
        number = other.number;
    }
    void display() {
        cout << "数据: number=" << number 
             << ", msg=" << (msg ? msg : "null") << endl;
    }
};
// 返回临时对象的函数
Data create_data() {
    return Data(42, "临时数据");  // 返回右值
}
int main() {
    cout << "=== 场景1：右值引用基本用法 ===" << endl;
    int a = 10;
    int &lref = a;          // 左值引用
    int &&rref = 100;       // 右值引用
    cout << "a=" << a << ", lref=" << lref << ", rref=" << rref << endl;
    cout << "\n=== 场景2：移动语义演示 ===" << endl;
    // 情况1：返回临时对象，调用移动构造
    Data d1 = create_data();
    d1.display();
    cout << "\n=== 场景3：拷贝 vs 移动 ===" << endl;
    // 情况2：拷贝构造（深拷贝）
    Data d2 = d1;           // d1是左值，调用拷贝构造
    d2.display();
    // 情况3：移动构造
    Data d3 = create_data(); // 临时对象是右值，调用移动构造
    d3.display();
    cout << "\n=== 程序结束 ===" << endl;
    return 0;
}