C ++ ความแตกต่างระหว่าง std :: ref (T) และ T &?

ฉันมีคำถามเกี่ยวกับโปรแกรมนี้:

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

ผลลัพธ์คือ:

false

ฉันอยากรู้ว่าถ้าstd::refไม่ส่งคืนการอ้างอิงของวัตถุมันจะทำอย่างไร โดยทั่วไปความแตกต่างระหว่าง:

T x;
auto r = ref(x);

และ

T x;
T &y = x;

นอกจากนี้ฉันต้องการทราบว่าเหตุใดจึงมีความแตกต่างนี้ ทำไมเราถึงต้องการstd::refหรือstd::reference_wrapperเมื่อเรามีข้อมูลอ้างอิง (เช่นT&)?

ดีrefสร้างวัตถุของการที่เหมาะสมที่reference_wrapperประเภทที่จะถือการอ้างอิงไปยังวัตถุ ซึ่งหมายความว่าเมื่อคุณสมัคร:

auto r = ref(x);

สิ่งนี้ส่งคืน a reference_wrapperและไม่ใช่การอ้างอิงโดยตรงไปยังx(ie T&) นี้reference_wrapper(คือr) T&แทนถือ

A reference_wrapperมีประโยชน์มากเมื่อคุณต้องการเลียนแบบreferenceวัตถุที่สามารถคัดลอกได้ (สามารถคัดลอกได้ทั้งแบบสร้างได้และสามารถคัดลอกได้ )

ใน C ++ เมื่อคุณสร้างการอ้างอิง (พูดy) กับวัตถุ (พูดx) แล้วyและxร่วมกันอยู่ฐาน นอกจากนี้yไม่สามารถอ้างถึงวัตถุอื่นใด นอกจากนี้คุณไม่สามารถสร้างอาร์เรย์ของการอ้างอิงได้เช่นรหัสเช่นนี้จะทำให้เกิดข้อผิดพลาด:

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

อย่างไรก็ตามสิ่งนี้ถูกกฎหมาย:

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

เมื่อพูดถึงปัญหาของคุณcout << is_same<T&,decltype(r)>::value;วิธีแก้ปัญหาคือ:

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

ให้ฉันแสดงโปรแกรม:

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

ดูที่นี่เราทำความรู้จักกับสามสิ่ง:

1. reference_wrapperวัตถุ (ที่นี่r) สามารถนำมาใช้ในการสร้างอาร์เรย์ของการอ้างอิงT&ซึ่งเป็นไปไม่ได้กับ

2. rทำหน้าที่เหมือนการอ้างอิงจริง (ดูว่าr.get()=70ค่าของการเปลี่ยนแปลงy)

3. rไม่เหมือนกับT&แต่r.get()เป็น วิธีการนี้ว่าrถือT&คือเป็นชื่อแนะนำเป็นห่อหุ้มรอบอ้างอิง T&

ฉันหวังว่าคำตอบนี้จะเพียงพอที่จะอธิบายข้อสงสัยของคุณ

std::reference_wrapper ได้รับการยอมรับจากสิ่งอำนวยความสะดวกมาตรฐานเพื่อให้สามารถส่งผ่านวัตถุโดยการอ้างอิงในบริบทแบบ pass-by-value

ตัวอย่างเช่นstd::bindสามารถนำไปใช้ในstd::ref()บางสิ่งบางอย่างส่งด้วยค่าและแกะกลับเข้าไปในข้อมูลอ้างอิงในภายหลัง

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

ตัวอย่างข้อมูลนี้แสดงผล:

10
20

ค่าของiได้ถูกเก็บไว้ (นำมาโดยค่า) ในf1จุดที่เริ่มต้น แต่f2ได้เก็บstd::reference_wrapperค่าไว้ตามค่าดังนั้นจึงทำงานเหมือนที่ใช้ในint&ไฟล์.

การอ้างอิง ( T&หรือT&&) เป็นองค์ประกอบพิเศษในภาษา C ++ อนุญาตให้จัดการวัตถุโดยการอ้างอิงและมีกรณีการใช้งานพิเศษในภาษา ตัวอย่างเช่นคุณไม่สามารถสร้างคอนเทนเนอร์มาตรฐานเพื่อเก็บข้อมูลอ้างอิงได้: vector<T&>มีรูปแบบไม่ถูกต้องและสร้างข้อผิดพลาดในการคอมไพล์

std::reference_wrapperบนมืออื่น ๆ ที่เป็นวัตถุ c ++ สามารถที่จะถือเป็นข้อมูลอ้างอิง ดังนั้นคุณสามารถใช้ในภาชนะมาตรฐานได้

std::refเป็นฟังก์ชันมาตรฐานที่ส่งคืนstd::reference_wrapperอาร์กิวเมนต์ ในแนวคิดเดียวกันให้std::crefกลับstd::reference_wrapperไปที่การอ้างอิง const

คุณสมบัติที่น่าสนใจอย่างหนึ่งของ a std::reference_wrapperคือมันมีoperator T& () const noexcept;. นั่นหมายความว่าแม้ว่าจะเป็นวัตถุจริงแต่ก็สามารถแปลงเป็นการอ้างอิงที่ถืออยู่ได้โดยอัตโนมัติ ดังนั้น:

• เนื่องจากเป็นวัตถุที่กำหนดสำเนาได้จึงสามารถใช้ในคอนเทนเนอร์หรือในกรณีอื่น ๆ ที่ไม่อนุญาตให้มีการอ้างอิง
• ด้วยเหตุoperator T& () const noexcept;นี้จึงสามารถใช้ที่ใดก็ได้ที่คุณสามารถใช้การอ้างอิงได้เนื่องจากจะถูกแปลงเป็นข้อมูลอ้างอิงโดยอัตโนมัติ