C++左值引用、右值引用应用场景分析

int main()
{
    int i = 0;
    i = 1;                  // i是变量，可修改左值，能放在赋值号左侧
    const int ci = 5;
    // ci = 6;             // 报错：const左值不可修改，但&ci可获取地址，仍是左值
    int* pi = &i;
    *pi = 1;                // *pi对指针解引用，左值
    int arr[5] = {0};
    arr[0] = 1;             // 数组元素，左值
    struct { int m_a; } st, *pst = &st;
    st.m_a = 1;             // 结构体成员，左值
    pst->m_a = 2;
    return 0;
}

int getNum()
{
    return 100;
}
int main()
{
    int i = 0, c = 0;
    i = 42;                  // 字面值42，纯右值
    c = 'a';                 // 字面值'a'，纯右值
    i = 1 + 2;               // 算术表达式结果，纯右值
    i = (c != 'a');          // 逻辑表达式结果，纯右值
    i = getNum();            // 非引用返回值，纯右值
    int&& rri = std::move(i);// std::move(i)的结果，将亡值，右值
    return 0;
}

int main()
{
    int a = 10;
    int& ra = a;             // 正确：非const左值引用绑定左值
    // int& rb = 10;         // 报错：非const左值引用无法绑定右值
    const int& rca = a;      // 正确：const左值引用绑定左值
    const int& rcb = 10;     // 正确：const左值引用绑定右值
    // rcb = 20;             // 报错：const引用无法修改绑定对象
    return 0;
}

类型&& 引用名 = 右值表达式;

#include <iostream>
using namespace std;
int getNum()
{
    return 100;
}
void func(int&& rri)
{
    rri = 0;
}
int main()
{
    // 1. 右值引用必须绑定右值
    int&& ri0 = 42;          // 正确：绑定字面量纯右值
    int&& ri1 = 1 + 2;       // 正确：绑定表达式结果纯右值
    int&& ri2 = getNum();    // 正确：绑定函数返回值纯右值
    // int&& ri3 = ri0;      // 报错：ri0是右值引用变量，本身是左值，无法绑定
    // 2. 可通过右值引用修改绑定的对象
    ri0 = 100;
    cout << "ri0 = " << ri0 << endl; // 输出：ri0 = 100
    // 3. 可获取右值引用的地址（证明它本身是左值）
    int* pi = &ri0;
    *pi = 200;
    cout << "*pi = " << *pi << ", ri0 = " << ri0 << endl; // 输出：*pi = 200, ri0 = 200
    // 4. 右值引用作为函数参数，接收右值
    func(1 + 2);
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
int main()
{
    string str = "Hello World!";
    cout << "move前：str = " << str << endl;
    // std::move将str左值转为右值，触发string的移动构造函数
    string tmp = std::move(str);
    cout << "move后：str = " << str << endl;  // 结果未定义，标准仅保证str可析构
    cout << "move后：tmp = " << tmp << endl;
    return 0;
}

#include <iostream>
#include <cstring>
using namespace std;
class MyString
{
public:
    char* data;
    size_t len;
    // 普通构造函数
    MyString(const char* str)
    {
        len = strlen(str);
        data = new char[len + 1];
        strcpy(data, str);
        cout << "构造函数：分配内存，地址=" << (void*)data << "，内容=" << data << endl;
    }
    // 拷贝构造函数（深拷贝）
    MyString(const MyString& other)
    {
        len = other.len;
        data = new char[len + 1];
        strcpy(data, other.data);
        cout << "拷贝构造函数：深拷贝内存，新地址=" << (void*)data << "，内容=" << data << endl;
    }
    // 拷贝赋值运算符（深拷贝）
    MyString& operator=(const MyString& other)
    {
        if (this == &other)
        {
            return *this;
        }
        // 释放自身原有资源
        delete[] data;
        // 深拷贝源对象资源
        len = other.len;
        data = new char[len + 1];
        strcpy(data, other.data);
        cout << "拷贝赋值运算符：深拷贝内存，新地址=" << (void*)data << "，内容=" << data << endl;
        return *this;
    }
    // 析构函数
    ~MyString()
    {
        if (data)
        {
            cout << "析构函数：释放内存，地址=" << (void*)data << "，内容=" << data << endl;
            delete[] data;
        }
        else
        {
            cout << "析构函数：资源已转移，无需释放" << endl;
        }
    }
};
MyString createString()
{
    MyString str("Hello C++");
    return str; // 返回临时对象，触发拷贝构造
}
int main()
{
    MyString str1("Hello World");
    MyString str2 = str1; // 触发拷贝构造
    MyString str3 = createString(); // 临时对象触发拷贝构造，随后销毁
    return 0;
}

#include <iostream>
#include <cstring>
using namespace std;
class MyString
{
public:
    char* data;
    size_t len;
    // 普通构造函数
    MyString(const char* str)
    {
        len = strlen(str);
        data = new char[len + 1];
        strcpy(data, str);
        cout << "构造函数：分配内存，地址=" << (void*)data << "，内容=" << data << endl;
    }
    // 拷贝构造函数（深拷贝）
    MyString(const MyString& other)
    {
        len = other.len;
        data = new char[len + 1];
        strcpy(data, other.data);
        cout << "拷贝构造函数：深拷贝内存，新地址=" << (void*)data << "，内容=" << data << endl;
    }
    // 移动构造函数（右值引用参数，资源转移）
    // noexcept关键字：告诉编译器该函数不会抛出异常，STL容器会优先调用
    MyString(MyString&& other) noexcept
    {
        // 直接转移源对象的资源，无需深拷贝
        data = other.data;
        len = other.len;
        // 源对象指针置空，避免析构时释放资源
        other.data = nullptr;
        other.len = 0;
        cout << "移动构造函数：转移资源，目标地址=" << (void*)data << endl;
    }
    // 拷贝赋值运算符（深拷贝）
    MyString& operator=(const MyString& other)
    {
        if (this == &other)
        {
            return *this;
        }
        delete[] data;
        len = other.len;
        data = new char[len + 1];
        strcpy(data, other.data);
        cout << "拷贝赋值运算符：深拷贝内存，新地址=" << (void*)data << "，内容=" << data << endl;
        return *this;
    }
    // 移动赋值运算符（右值引用参数，资源转移）
    MyString& operator=(MyString&& other) noexcept
    {
        if (this == &other)
        {
            return *this;
        }
        // 释放自身原有资源
        delete[] data;
        // 转移源对象资源
        data = other.data;
        len = other.len;
        // 源对象指针置空
        other.data = nullptr;
        other.len = 0;
        cout << "移动赋值运算符：转移资源，目标地址=" << (void*)data << endl;
        return *this;
    }
    // 析构函数
    ~MyString()
    {
        if (data)
        {
            cout << "析构函数：释放内存，地址=" << (void*)data << "，内容=" << data << endl;
            delete[] data;
        }
        else
        {
            cout << "析构函数：资源已转移，无需释放" << endl;
        }
    }
};
MyString createString()
{
    MyString str("Hello C++");
    return str;
}
int main()
{
    MyString str1("Hello World");
    MyString str2 = std::move(str1); // 触发移动构造，转移str1的资源
    MyString str3 = createString(); // 临时对象是右值，触发移动构造
    str3 = MyString("Hello Move"); // 临时对象触发移动赋值
    return 0;
}

// 模板参数推导，T&&是万能引用
template<typename T>
void func(T&& arg)
{
}

// 具体类型，int&&是普通右值引用
void func2(int&& arg)
{
}

int main()
{
    int a = 10;
    func(a);  // 正确：万能引用绑定左值
    func(10); // 正确：万能引用绑定右值
    // func2(a); // 报错：普通右值引用无法绑定左值
    func2(10); // 正确：普通右值引用绑定右值
    return 0;
}

#include <iostream>
#include <utility>
using namespace std;
// 重载函数，区分左值和右值参数
void process(int& x)
{
    cout << "左值引用版本被调用，值=" << x << endl;
}
void process(int&& x)
{
    cout << "右值引用版本被调用，值=" << x << endl;
}
// 不使用完美转发的模板函数
template<typename T>
void noForward(T&& arg)
{
    cout << "无完美转发：";
    process(arg); // arg是有名字的变量，本身是左值，永远调用左值版本
}
// 使用完美转发的模板函数
template<typename T>
void withForward(T&& arg)
{
    cout << "有完美转发：";
    process(std::forward<T>(arg)); // 完美转发，保留原始左值/右值属性
}
int main()
{
    int a = 5;
    cout << "===== 传入左值a =====" << endl;
    noForward(a);
    withForward(a);
    cout << "\n===== 传入右值10 =====" << endl;
    noForward(10);
    withForward(10);
    return 0;
}

void func(int&& x)
{
}
void test(int&& arg)
{
    // func(arg); // 报错：arg是右值引用变量，本身是左值
    func(std::move(arg)); // 正确
}

class Test
{
public:
    // 这里的T&&不是万能引用，因为类实例化时T已经确定，没有参数推导
    template<typename T>
    void func(T&& arg);
};