C ++ Różnica między std :: ref (T) a T &?

Mam kilka pytań dotyczących tego programu:

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

Wynik to:

false

Chcę wiedzieć, jeśli std::refnie zwraca odwołania do obiektu, to co robi? Zasadniczo jaka jest różnica między:

T x;
auto r = ref(x);

i

T x;
T &y = x;

Chcę też wiedzieć, dlaczego istnieje ta różnica? Dlaczego potrzebujemy std::reflub std::reference_wrapperkiedy mamy referencje (tj. T&)?

Well refkonstruuje obiekt odpowiedniego reference_wrappertypu, aby przechowywać odwołanie do obiektu. Co oznacza, że ​​kiedy aplikujesz:

auto r = ref(x);

Zwraca reference_wrappera nie bezpośrednie odwołanie do x(tj T&.). To reference_wrapper(tj. r) Zamiast tego utrzymuje T&.

A reference_wrapperjest bardzo przydatne, gdy chcesz emulować a referenceobiektu, który można skopiować (można go zarówno konstruować, jak i przypisywać do kopii ).

W C ++, po utworzeniu odniesienia (powiedzmy y) do obiektu (powiedzmy x), to yi xdzielić ten sam adres bazowy . Ponadto ynie może odnosić się do żadnego innego przedmiotu. Nie możesz również utworzyć tablicy referencji, tj. Kod taki jak ten spowoduje błąd:

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

Jednak jest to zgodne z prawem:

#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
*/

Mówiąc o Twoim problemie cout << is_same<T&,decltype(r)>::value;, rozwiązaniem jest:

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

Pokażę wam program:

#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
*/

Tutaj poznajemy trzy rzeczy:

1. reference_wrapperPrzedmiotu (tutaj r) mogą być wykorzystywane do tworzenia szereg odnośników , których nie było możliwe T&.

2. rfaktycznie działa jak prawdziwe odniesienie (zobacz, jak r.get()=70zmieniła się wartość y).

3. rto nie to samo, co T&ale r.get()jest. Oznacza to, że rhold T&ie, jak sama nazwa wskazuje, jest opakowaniem wokół referencji T& .

Mam nadzieję, że ta odpowiedź jest więcej niż wystarczająca, aby wyjaśnić Twoje wątpliwości.

std::reference_wrapper jest rozpoznawany przez standardowe narzędzia jako zdolny do przekazywania obiektów przez odwołanie w kontekstach przekazujących wartość.

Na przykład, std::bindmoże przejąć std::ref()coś do czegoś, przesłać to według wartości, a później rozpakować z powrotem do odniesienia.

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();
}

Ten fragment kodu wyświetla:

10
20

Wartość izostała zapisana (przyjęta przez wartość) w f1punkcie, w którym została zainicjowana, ale f2zachowała std::reference_wrapperwartość według, a zatem zachowuje się tak, jakby przyjęła plik int&.

Odniesienie ( T&lub T&&) to specjalny element w języku C ++. Pozwala na manipulowanie obiektem poprzez odniesienie i ma specjalne przypadki użycia w języku. Na przykład nie można utworzyć standardowego kontenera do przechowywania odniesień: vector<T&>jest źle sformułowany i generuje błąd kompilacji.

A std::reference_wrapperz drugiej strony jest obiektem C ++ zdolnym do przechowywania referencji. W związku z tym można go używać w standardowych pojemnikach.

std::refjest standardową funkcją, która zwraca a std::reference_wrapperw swoim argumencie. W tym samym pomyśle std::crefpowraca std::reference_wrapperdo odwołania do stałej.

Jedną z interesujących właściwości a std::reference_wrapperjest to, że ma rozszerzenie operator T& () const noexcept;. Oznacza to, że nawet jeśli jest to prawdziwy obiekt , można go automatycznie przekształcić w odniesienie, które posiada. Więc:

• ponieważ jest to obiekt przypisywalny do kopii, może być używany w kontenerach lub w innych przypadkach, w których odniesienia nie są dozwolone
• dzięki operator T& () const noexcept;niemu można go używać wszędzie tam, gdzie można użyć odniesienia, ponieważ zostanie na niego automatycznie przekonwertowany.