C ++ Perbedaan antara std :: ref (T) dan T &?

Saya punya beberapa pertanyaan tentang program ini:

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

Outputnya adalah:

false

Saya ingin tahu, jika std::reftidak mengembalikan referensi suatu objek, lalu apa fungsinya? Pada dasarnya apa perbedaan antara:

T x;
auto r = ref(x);

dan

T x;
T &y = x;

Juga, saya ingin tahu mengapa perbedaan ini ada? Mengapa kita membutuhkan std::refatau std::reference_wrapperketika kita memiliki referensi (yaitu T&)?

Well refmembangun sebuah objek dengan reference_wrappertipe yang sesuai untuk menampung referensi ke sebuah objek. Yang artinya saat Anda melamar:

auto r = ref(x);

Ini mengembalikan a reference_wrapperdan bukan referensi langsung ke x(yaitu T&). Ini reference_wrapper(yaitu r) sebagai gantinya berlaku T&.

A reference_wrappersangat berguna ketika Anda ingin meniru referenceobjek yang dapat disalin (keduanya dapat dikopi-konstruktif dan dapat dialihkan ).

Dalam C ++, setelah Anda membuat referensi (katakanlah y) ke obyek (katakanlah x), kemudian ydan xberbagi sama alamat dasar . Selain itu, ytidak dapat merujuk ke objek lain. Anda juga tidak dapat membuat array referensi, misalnya kode seperti ini akan menimbulkan kesalahan:

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

Namun ini 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
*/

Berbicara tentang masalah Anda dengan cout << is_same<T&,decltype(r)>::value;, solusinya adalah:

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

Mari saya tunjukkan sebuah 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
*/

Lihat di sini kita mengetahui tiga hal:

1. Sebuah reference_wrapperobjek (di sini r) dapat digunakan untuk membuat array referensi yang tidak memungkinkan T&.

2. rsebenarnya bertindak seperti referensi nyata (lihat bagaimana r.get()=70mengubah nilai y).

3. rtidak sama T&tetapi r.get(). Ini berarti bahwa rholding T&seperti namanya adalah pembungkus di sekitar referensi T& .

Saya harap jawaban ini lebih dari cukup untuk menjelaskan keraguan Anda.

std::reference_wrapper dikenali oleh fasilitas standar untuk dapat melewatkan objek dengan referensi dalam konteks nilai-demi-nilai.

Misalnya, std::binddapat menerima std::ref()ke sesuatu, mengirimkannya berdasarkan nilai, dan mengekstraknya kembali menjadi referensi nanti.

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

Cuplikan ini menghasilkan:

10
20

Nilai itelah disimpan (diambil oleh nilai) ke f1dalam titik inisialisasi, tetapi f2telah disimpan std::reference_wrapperoleh nilai, dan dengan demikian berperilaku seperti yang diambil di file int&.

Referensi ( T&atau T&&) adalah elemen khusus dalam bahasa C ++. Ini memungkinkan untuk memanipulasi objek dengan referensi dan memiliki kasus penggunaan khusus dalam bahasa tersebut. Misalnya, Anda tidak dapat membuat penampung standar untuk menyimpan referensi: vector<T&>bentuknya tidak bagus dan menghasilkan kesalahan kompilasi.

A std::reference_wrapperdi sisi lain adalah objek C ++ yang dapat menampung referensi. Dengan demikian, Anda dapat menggunakannya dalam wadah standar.

std::refadalah fungsi standar yang mengembalikan a std::reference_wrapperpada argumennya. Dalam ide yang sama, std::crefkembali std::reference_wrapperke referensi const.

Salah satu properti yang menarik dari a std::reference_wrapper, adalah memiliki operator T& () const noexcept;. Itu berarti bahwa meskipun itu adalah objek yang sebenarnya , itu dapat secara otomatis diubah menjadi referensi yang dipegangnya. Begitu:

• karena ini adalah objek yang dapat disalin, dapat digunakan dalam wadah atau dalam kasus lain di mana referensi tidak diperbolehkan
• berkat sifatnya operator T& () const noexcept;, ini dapat digunakan di mana pun Anda dapat menggunakan referensi, karena itu akan secara otomatis dikonversi ke dalamnya.