C ++ Diferença entre std :: ref (T) e T &?

Tenho algumas perguntas 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;
}

O resultado é:

false

Eu quero saber, se std::refnão retorna a referência de um objeto, então o que ele faz? Basicamente, qual é a diferença entre:

T x;
auto r = ref(x);

e

T x;
T &y = x;

Além disso, quero saber por que existe essa diferença? Por que precisamos std::refou std::reference_wrapperquando temos referências (ou seja T&)?

O Well refconstrói um objeto do reference_wrappertipo apropriado para manter uma referência a um objeto. O que significa quando você se inscreve:

auto r = ref(x);

Isso retorna a reference_wrappere não uma referência direta a x(ou seja T&). Este reference_wrapper(isto é r), em vez disso, é válido T&.

A reference_wrapperé muito útil quando você deseja emular a referencede um objeto que pode ser copiado (é tanto construtível por cópia quanto atribuível por cópia ).

Em C ++, uma vez que você criar uma referência (digamos y) a um objeto (digamos x), em seguida, ye xcompartilham o mesmo endereço de base . Além disso, ynão pode se referir a nenhum outro objeto. Além disso, você não pode criar uma matriz de referências, ou seja, um código como este gerará um erro:

#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;
}

No entanto, isso é 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
*/

Falando sobre seu problema com cout << is_same<T&,decltype(r)>::value;, a solução é:

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

Deixe-me mostrar um 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
*/

Veja aqui, nós conhecemos três coisas:

1. Um reference_wrapperobjeto (aqui r) pode ser usado para criar uma matriz de referências que não foi possível com T&.

2. rrealmente age como uma referência real (veja como r.get()=70mudou o valor de y).

3. rnão é o mesmo, T&mas r.get()é. Isso significa que rmantém, T&ou seja, como o nome sugere, é um invólucro em torno de uma referência T& .

Espero que esta resposta seja mais do que suficiente para esclarecer suas dúvidas.

std::reference_wrapper é reconhecido pelas instalações padrão por ser capaz de passar objetos por referência em contextos de passagem por valor.

Por exemplo, std::bindpode receber o std::ref()para algo, transmiti-lo por valor e descompactá-lo em uma referência posteriormente.

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 snippet produz:

10
20

O valor de ifoi armazenado (tomado por valor) f1no ponto em que foi inicializado, mas f2manteve um std::reference_wrappervalor por e, portanto, se comporta como se tivesse recebido um int&.

Uma referência ( T&ou T&&) é um elemento especial na linguagem C ++. Permite manipular um objeto por referência e possui casos de uso especiais na linguagem. Por exemplo, você não pode criar um contêiner padrão para conter referências: vector<T&>está malformado e gera um erro de compilação.

Por std::reference_wrapperoutro lado, A é um objeto C ++ capaz de conter uma referência. Como tal, você pode usá-lo em contêineres padrão.

std::refé uma função padrão que retorna um std::reference_wrapperem seu argumento. Na mesma ideia, std::crefretorna std::reference_wrappera uma referência const.

Uma propriedade interessante de a std::reference_wrapperé que ele possui um operator T& () const noexcept;. Isso significa que mesmo se for um objeto verdadeiro , ele pode ser convertido automaticamente para a referência que está mantendo. Então:

• por ser um objeto de cópia, pode ser usado em containers ou em outros casos onde referências não são permitidas
• graças a operator T& () const noexcept;ele, pode ser usado em qualquer lugar onde você possa usar uma referência, pois será automaticamente convertido para ela.