C++ Rvalue Reference

Type&& reference_name = rvalue_expression;

int&& r_ref1 = 42;                  // Valid: Binds to a prvalue (literal)

std::string get_string();
std::string&& r_ref2 = get_string(); // Valid: Binds to a prvalue (temporary return value)

int x = 10;
// int&& r_ref3 = x;                // Error: Cannot bind rvalue reference to an lvalue

int&& r_ref4 = static_cast<int&&>(x); // Valid: Binds to an xvalue (explicit cast)
int&& r_ref5 = std::move(x);          // Valid: std::move is a standard library cast to T&&

void process(std::string& str);       // Overload 1: Binds to mutable lvalues
void process(const std::string& str); // Overload 2: Binds to const lvalues and rvalues (fallback)
void process(std::string&& str);      // Overload 3: Binds specifically to mutable rvalues

std::string name = "C++";
process(name);                        // Resolves to Overload 1
process(std::string("C++"));          // Resolves to Overload 3

void consume(std::string&& temp_str) {
    // 'temp_str' is an lvalue here, despite its type being std::string&&.
    
    // process(temp_str);             // This would call process(std::string&)
    
    // To pass it onward as an rvalue, it must be explicitly cast again:
    process(std::move(temp_str));     // Calls process(std::string&&)
}

template <typename T>
void deduce_type(T&& param); // T&& is a forwarding reference, not an rvalue reference

auto&& var = x;              // auto&& is a forwarding reference