左值和右值，左值引用和右值引用

---

1. 左值和右值

左值（lvalue）：指向内存位置的表达式，并且允许我们通过&操作符取得那个内存位置的地址。
左值通常指代内存中有确定存储位置的对象，这意味着它们的地址可以被获取。
右值（rvalue）：不是左值的表达式。
右值指的是那些不具有持久存储位置的表达式的结果，它们通常用于临时表达式的结果或字面值。

2. 左值引用和右值引用

假设 X 为任意类型，那么：
X& 就是一个左值引用；
X&& 就是一个右值引用。

右值引用是C++ 11引入的特性，至少用来解决如下两个问题：
1）实现move语义
2）完美转发

2.1 std::move

在C++11之前，对象数据的转移通常依赖于拷贝构造函数和赋值操作符，这可能会导致不必要的临时对象的创建和销毁，从而降低程序的效率。移动语义允许资源的所有权从一个对象转移到另一个对象，避免了不必要的拷贝。这是通过移动构造函数和移动赋值操作符来实现的，它们接受右值引用作为参数，从而标识对象是可以“移动”的。

移动构造函数和移动赋值操作符是 C++11 引入的两个重要特性，它们是实现移动语义（Move Semantics）的关键。这两个特性允许对象在适当的时候“移动”其内部资源，而非复制，从而提高效率。

代码示例：

#include <iostream>
#include <cstring>  // for strlen, strcpy
#include <utility>  // for std::move

class String {
public:
    // 默认构造函数
    String() : data_(nullptr) {}

    // 构造函数
    String(const char* str) {
        size_t size = strlen(str) + 1;
        data_ = new char[size];
        strcpy(data_, str);
    }

    // 析构函数
    ~String() {
        delete[] data_;
    }

    // 拷贝构造函数
    String(const String& other) {
        size_t size = strlen(other.data_) + 1;
        data_ = new char[size];
        strcpy(data_, other.data_);
        std::cout << "Called Copy Constructor\n";
    }

    // 移动构造函数
    String(String&& other) noexcept : data_(other.data_) {
        other.data_ = nullptr;
        std::cout << "Called Move Constructor\n";
    }

    // 用于演示的打印函数
    void print() const {
        if (data_) {
            std::cout << data_ << std::endl;
        } else {
            std::cout << "Empty String" << std::endl;
        }
    }

private:
    char* data_;
};

int main() {
    String hello("Hello, world!");
    std::cout << "Before moving:" << std::endl;
    hello.print();

    // 使用 std::move 来移动 hello 对象
    String moved_hello = std::move(hello);
    std::cout << "After moving:" << std::endl;
    moved_hello.print();
    hello.print();  // 此时 hello 为空

    return 0;
}

2.2 std::forward

完美转发是指在模板函数中，完整无缺地将参数转发给另一个函数的能力，同时保持所有参数的左值/右值属性及其const/volatile属性不变。在C++11之前，实现完美转发几乎是不可能的，因为函数模板不能区分传递给它的参数是左值还是右值。

通过使用右值引用和引用折叠规则（Reference Collapsing Rules），C++11的std::forward函数能够实现完美转发。这允许开发者编写接受任意参数的模板函数，并将这些参数以其原始的左值或右值形式转发给其他函数。这在编写泛型库时特别有用，如标准模板库（STL）中的容器和算法，它们可以高效地处理各种类型的参数，而不会引入额外的性能开销。

代码示例:

#include <iostream>
#include <utility>  // for std::forward

// 目标函数，可以处理左值和右值
void process(int& i) {
    std::cout << "处理左值: " << i << std::endl;
}
void process(int&& i) {
    std::cout << "处理右值: " << i << std::endl;
}

// 包装器函数，使用完美转发将参数转发给process函数
template<typename T>
void wrapper(T&& arg) {
    process(std::forward<T>(arg));  // 使用std::forward保持arg的左值/右值属性
}

int main() {
    int a = 5;
    wrapper(a);  // a是左值
    wrapper(10); // 10是右值

    return 0;
}

3. 右值引用是右值吗？

声明为右值引用的东西可以是左值，也可以是右值。区分标准为：
如果它有一个名字，就是左值；否则，就是右值。

代码示例：

void process(const int& value) {
    // 对左值的处理
    std::cout << "处理左值: " << value << std::endl;
}

void process(int&& value) {
    // 对右值的处理
    std::cout << "处理右值: " << value << std::endl;
}

int main() {
    int&& rvalueRef = 5; // rvalueRef是一个右值引用
    process(rvalueRef);  // 这里rvalueRef作为一个左值传递给process函数
    process(5); // 直接使用字面量5，它是一个右值
    return 0;
}

4. 引用坍缩（引用折叠）（reference collapsing）

C++11引入引用坍缩（引用折叠）规则：

• A& & becomes A&
• A& && becomes A&
• A&& & becomes A&
• A&& && becomes A&&

---

参考资料

http://thbecker.net/articles/rvalue_references/section_01.html