referencias de lvalues ​​y referencias de rvalues ​​en C++ con ejemplos

Requisitos previos: lvalue y rvalue en C++ , Referencias en C++
“l-value” hace referencia a una ubicación de memoria que identifica un objeto. «valor r» se refiere al valor de datos que se almacena en alguna dirección en la memoria. Las referencias en C++ no son más que la alternativa a la variable ya existente. Se declaran usando el ‘&’ antes del nombre de la variable.

Ejemplo: 

int a = 10;

// Declaring lvalue reference
int& lref = a;

// Declaring rvalue reference
int&& rref = 20;

A continuación se muestra la implementación de lvalue y rvalue:

// C++ program to illustrate the
// lvalue and rvalue
 
#include <iostream>
using namespace std;
 
// Driver Code
int main()
{
    // Declaring the variable
    int a{ 10 };
 
    // Declaring reference to
    // already created variable
    int& b = a;
 
    // Provision made to display
    // the boolean output in the
    // form of True and False
    // instead of 1 and
    cout << boolalpha;
 
    // Comparing the address of both the
    // variable and its reference and it
    // will turn out to be same
    cout << (&a == &b) << endl;
    return 0;
}

true

Explicación : el siguiente código imprimirá True ya que ambas variables apuntan a la misma ubicación de memoria. b es solo un nombre alternativo a la memoria asignada a la variable a. La referencia declarada en el código anterior es la referencia lvalue (es decir, se refiere a la variable en el lvalue) de manera similar, también se pueden declarar las referencias para los valores.

Las referencias de rvalue tienen dos propiedades que son útiles : 

1. Las referencias de rvalue extienden la vida útil del objeto temporal al que están asignadas.
2. Las referencias de valor de r que no son constantes le permiten modificar el valor de r.

Importante: las referencias de lvalue se pueden asignar con rvalues ​​pero las referencias de rvalue no se pueden asignar a lvalue . 

// C++ program to illustrate the
// lvalue and rvalue
#include <iostream>
using namespace std;
 
// Driver Code
int main()
{
    int a = 10;
 
    // Declaring lvalue reference
    // (i.e variable a)
    int& lref = a;
 
    // Declaring rvalue reference
    int&& rref = 20;
 
    // Print the values
    cout << "lref = " << lref << endl;
    cout << "rref = " << rref << endl;
 
    // Value of both a
    // and lref is changed
    lref = 30;
 
    // Value of rref is changed
    rref = 40;
    cout << "lref = " << lref << endl;
    cout << "rref = " << rref << endl;
 
    // This line will generate an error
    // as l-value cannot be assigned
    // to the r-value references
    // int &&ref = a;
    return 0;
}

lref = 10
rref = 20
lref = 30
rref = 40

Usos de las referencias lvalue : 

1. Las referencias de lvalue se pueden usar para crear un alias de un objeto existente.
2. También se pueden utilizar para implementar la semántica de paso por referencia.

// C++ program to illustrate lvalue
#include <iostream>
using namespace std;
 
// Creating the references of the
// parameter passed to the function
void swap(int& x, int& y)
{
    int temp = x;
    x = y;
    y = temp;
}
 
// Driver Code
int main()
{
    // Given values
    int a{ 10 }, b{ 20 };
    cout << "a = " << a
         << " b = " << b << endl;
 
    // Call by Reference
    swap(a, b);
 
    // Print the value
    cout << "a = " << a
         << " b = " << b << endl;
    return 0;
}

a = 10 b = 20
a = 20 b = 10

Nota: Cuando la función devuelve la referencia de valor l, la expresión se convierte en expresión de valor l.

Usos de las referencias de rvalue : 

1. Se utilizan para trabajar con el constructor de movimientos y la asignación de movimientos.
2. no se puede vincular una referencia de valor l no constante de tipo ‘ int& ‘ a un valor r de tipo ‘int’.
3. no se pueden vincular referencias de valor real de tipo ‘ int&& ‘ a valorl de tipo ‘int’.

Programa 1:  

// C++ program to illustrate rvalue
#include <iostream>
using namespace std;
 
// lvalue reference to the lvalue
// passed as the parameter
void printReferenceValue(int& x)
{
    cout << x << endl;
}
 
// Driver Code
int main()
{
    // Given value
    int a{ 10 };
 
    // Function call is made lvalue & can
    // be assigned to lvalue reference
    printReferenceValue(a);
    return 0;
}

10

Programa 2: 

// C++ program to illustrate rvalue
#include <iostream>
using namespace std;
 
// Declaring rvalue reference to the
// rvalue passed as the parameter
void printReferenceValue(int&& x)
{
    cout << x << endl;
}
 
// Driver Code
int main()
{
    // Given value a
    int a{ 10 };
 
    // Works fine as the function is
    // called with rvalue
    printReferenceValue(100);
    return 0;
}

100