C++ 左值、右值、左值引用、右值引用的用途及区别

int a = 10; // a 是左值（有名字、能取地址）
int* p = &a; // 合法：左值可以取地址
const int b = 20; // b 是 const 左值（有名字、能取地址，但不能修改）
// b = 30; // 错误：const 左值不可修改
int arr[5]; 
arr[0] = 1; // arr[0] 是左值（数组元素有地址）

int a = 10;
int b = 20;
// 以下都是右值
100; // 字面量（无名字，不能取地址）
a + b; // 表达式结果（临时值，无名字）
func(); // 函数返回值（非引用类型时，是临时值）

int a = 10;
int& ref_a = a; // 正确：左值引用绑定左值（ref_a 是 a 的别名）
ref_a = 20; // 等价于 a = 20，a 现在是 20

// int& ref = 10; // 错误：左值引用不能绑定右值（10 是右值）

const int& ref = 10; // 正确：const 左值引用可绑定右值
// 原理：编译器会生成临时变量存储 10，ref 绑定这个临时变量（临时变量生命周期被延长至 ref 相同）

void func(const vector<int>& v) { ... } // 传引用，无拷贝

void increment(int& x) { x++; }
int a = 5;
increment(a); // a 变为 6

int&& ref1 = 10; // 正确：右值引用绑定纯右值（10 是右值）
int a = 10, b = 20;
int&& ref2 = a + b; // 正确：右值引用绑定表达式结果（右值）

int a = 10;
// int&& ref = a; // 错误：右值引用不能直接绑定左值

int a = 10;
int&& ref = std::move(a); // 正确：std::move 将 a 转为右值引用

class MyString {
private:
    char* data; // 存储字符串的动态内存
public:
    // 普通构造函数
    MyString(const char* str) {
        size_t len = strlen(str);
        data = new char[len + 1];
        strcpy(data, str);
        cout << "构造函数：分配内存" << endl;
    }
    // 拷贝构造函数（左值引用参数，深拷贝）
    MyString(const MyString& other) {
        size_t len = strlen(other.data);
        data = new char[len + 1];
        strcpy(data, other.data);
        cout << "拷贝构造：深拷贝（性能差）" << endl;
    }
    // 移动构造函数（右值引用参数，直接窃取资源）
    MyString(MyString&& other) noexcept {
        data = other.data; // 直接接管 other 的内存
        other.data = nullptr; // other 放弃资源（避免析构时重复释放）
        cout << "移动构造：窃取资源（性能好）" << endl;
    }
    ~MyString() {
        if (data) delete[] data;
        cout << "析构函数：释放内存" << endl;
    }
};
int main() {
    MyString s1("hello"); // 调用普通构造
    MyString s2 = s1; // 调用拷贝构造（s1 是左值，必须深拷贝）
    MyString s3 = MyString("world"); // 调用移动构造（临时对象是右值，直接窃取资源）
    MyString s4 = std::move(s1); // 调用移动构造（s1 被转为右值，资源被 s4 窃取）
    return 0;
}

template <typename T>
void func(T&& t) { // 万能引用（仅模板中 T&& 才是万能引用）
    // 根据传入的参数，t 可能是左值引用或右值引用
}
int main() {
    int a = 10;
    func(a); // 传入左值，T 推导为 int&，func 实际为 void func(int& t)
    func(20); // 传入右值，T 推导为 int，func 实际为 void func(int&& t)
    return 0;
}

void target(int& x) { cout << "左值版本" << endl; }
void target(int&& x) { cout << "右值版本" << endl; }
template <typename T>
void func(T&& t) {
    target(t); // 错误：t 是引用（有名字），被当作左值处理，始终调用 target(int&)
}
int main() {
    int a = 10;
    func(a); // 传入左值，期望调用 target(int&) → 实际正确
    func(20); // 传入右值，期望调用 target(int&&) → 实际错误（调用了左值版本）
    return 0;
}

template <typename T>
void func(T&& t) {
    target(std::forward<T>(t)); // 完美转发：保持 t 的原始属性
}
int main() {
    int a = 10;
    func(a); // 传入左值 → 转发为左值 → 调用 target(int&)
    func(20); // 传入右值 → 转发为右值 → 调用 target(int&&)
    return 0;
}

class MyString {
private:
    char* data;
    size_t size;
public:
    // 移动构造函数
    MyString(MyString&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }
    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
    // 析构函数
    ~MyString() {
        delete[] data;
    }
    // 禁用拷贝（可选）
    MyString(const MyString&) = delete;
    MyString& operator=(const MyString&) = delete;
};

// 包装器函数
template<typename Func, typename... Args>
auto wrapper(Func&& func, Args&&... args) {
    return std::forward<Func>(func)(std::forward<Args>(args)...);
}
// 工厂函数
template<typename T, typename... Args>
T create(Args&&... args) {
    return T(std::forward<Args>(args)...);
}

int&& ref = 10; // ref 是右值引用，但自身是左值
int& ref2 = ref; // 正确：ref 是左值，可绑定到左值引用

左值/右值
├── 左值 (lvalue)：有名字、可寻址
├── 右值 (rvalue)：临时对象、字面量
│   ├── 纯右值 (prvalue)
│   └── 将亡值 (xvalue)
│
引用类型
├── 左值引用 (&)：绑定左值
├── 右值引用 (&&)：绑定右值
└── 通用引用 (T&&)：模板推导
    └── 完美转发 (std::forward)