C ++ Diferencia entre std :: ref (T) y T &?

Tengo algunas preguntas sobre este programa:

#include <iostream>
#include <type_traits>
#include <functional>
using namespace std;
template <typename T> void foo ( T x )
{
    auto r=ref(x);
    cout<<boolalpha;
    cout<<is_same<T&,decltype(r)>::value;
}
int main()
{
    int x=5;
    foo (x);
    return 0;
}

La salida es:

false

Quiero saber, si std::refno devuelve la referencia de un objeto, ¿qué hace? Básicamente, ¿cuál es la diferencia entre:

T x;
auto r = ref(x);

y

T x;
T &y = x;

Además, quiero saber por qué existe esta diferencia. ¿Por qué necesitamos std::refo std::reference_wrappercuando tenemos referencias (es decir T&)?

Well refconstruye un objeto del reference_wrappertipo apropiado para contener una referencia a un objeto. Lo que significa que cuando aplicas:

auto r = ref(x);

Esto devuelve a reference_wrappery no una referencia directa a x(ie T&). En cambio, esto reference_wrapper(es decir r) se mantiene T&.

Una reference_wrapperes muy útil cuando se desea emular una referencede un objeto que se puede copiar (que es a la vez -construible copia y copiar asignable ).

En C ++, una vez que crea una referencia (digamos y) a un objeto (digamos x), entonces yy xcomparte la misma dirección base . Además, yno puede referirse a ningún otro objeto. Además, no puede crear una matriz de referencias, es decir, un código como este arrojará un error:

#include <iostream>
using namespace std;

int main()
{
    int x=5, y=7, z=8;
    int& arr[] {x,y,z};    // error: declaration of 'arr' as array of references
    return 0;
}

Sin embargo, esto es legal:

#include <iostream>
#include <functional>  // for reference_wrapper
using namespace std;

int main()
{
    int x=5, y=7, z=8;
    reference_wrapper<int> arr[] {x,y,z};
    for (auto a: arr)
        cout << a << " ";
    return 0;
}
/* OUTPUT:
5 7 8
*/

Hablando de tu problema con cout << is_same<T&,decltype(r)>::value;, la solución es:

cout << is_same<T&,decltype(r.get())>::value;  // will yield true

Déjame mostrarte un programa:

#include <iostream>
#include <type_traits>
#include <functional>
using namespace std;

int main()
{
    cout << boolalpha;
    int x=5, y=7;
    reference_wrapper<int> r=x;   // or auto r = ref(x);
    cout << is_same<int&, decltype(r.get())>::value << "\n";
    cout << (&x==&r.get()) << "\n";
    r=y;
    cout << (&y==&r.get()) << "\n";
    r.get()=70;
    cout << y;
    return 0;
}
/* Ouput:
true
true
true
70
*/

Mira aquí llegamos a saber tres cosas:

1. Un reference_wrapperobjeto (aquí r) se puede usar para crear una matriz de referencias que no era posible con T&.

2. ren realidad actúa como una referencia real (vea cómo r.get()=70cambió el valor de y).

3. rno es lo mismo que T&pero r.get()es. Esto significa que se rmantiene, T&es decir, como sugiere su nombre, es un envoltorio alrededor de una referencia T& .

Espero que esta respuesta sea más que suficiente para explicar tus dudas.

std::reference_wrapper es reconocido por las instalaciones estándar para poder pasar objetos por referencia en contextos de paso por valor.

Por ejemplo, std::bindpuede std::ref()incorporar a algo, transmitirlo por valor y descomprimirlo en una referencia más adelante.

void print(int i) {
    std::cout << i << '\n';
}

int main() {
    int i = 10;

    auto f1 = std::bind(print, i);
    auto f2 = std::bind(print, std::ref(i));

    i = 20;

    f1();
    f2();
}

Este fragmento da como resultado:

10
20

El valor de ise ha almacenado (tomado por valor) en f1el punto en el que se inicializó, pero f2ha mantenido un std::reference_wrappervalor por valor y, por lo tanto, se comporta como si hubiera tomado un valor int&.

Una referencia ( T&o T&&) es un elemento especial en el lenguaje C ++. Permite manipular un objeto por referencia y tiene casos de uso especiales en el lenguaje. Por ejemplo, no puede crear un contenedor estándar para contener referencias: vector<T&>está mal formado y genera un error de compilación.

A, std::reference_wrapperpor otro lado, es un objeto C ++ capaz de contener una referencia. Como tal, puede usarlo en contenedores estándar.

std::refes una función estándar que devuelve un std::reference_wrapperen su argumento. En la misma idea, std::crefvuelve std::reference_wrappera una referencia constante.

Una propiedad interesante de a std::reference_wrapper, es que tiene un operator T& () const noexcept;. Eso significa que incluso si es un objeto verdadero , se puede convertir automáticamente a la referencia que contiene. Entonces:

• al ser un objeto asignable por copia, se puede utilizar en contenedores o en otros casos donde no se permiten referencias
• gracias a operator T& () const noexcept;él, se puede usar en cualquier lugar donde pueda usar una referencia, ya que se convertirá automáticamente a ella.