ข้อดีของการใช้การอ้างอิงการส่งต่อแบบอิงตามช่วงสำหรับลูปคืออะไร?

const auto&จะเพียงพอถ้าฉันต้องการดำเนินการอ่านอย่างเดียว อย่างไรก็ตามฉันได้ชน

for (auto&& e : v)  // v is non-const

สองสามครั้งเมื่อเร็ว ๆ นี้ สิ่งนี้ทำให้ฉันสงสัย:

เป็นไปได้ไหมว่าในบางกรณีมุมที่คลุมเครือมีประโยชน์ด้านประสิทธิภาพในการใช้การอ้างอิงการส่งต่อเมื่อเทียบกับauto&หรือconst auto&?

( shared_ptrเป็นผู้ต้องสงสัยคดีมุมอับ)

อัปเดต สองตัวอย่างที่ฉันพบในรายการโปรดของฉัน:

ข้อเสียของการใช้การอ้างอิง const เมื่อทำซ้ำในประเภทพื้นฐานหรือไม่?
ฉันสามารถทำซ้ำค่าของแผนที่โดยใช้ range-based for loop ได้หรือไม่?

โปรดตั้งสมาธิกับคำถาม: เหตุใดฉันจึงต้องการใช้ auto && แบบอิงตามช่วงสำหรับลูป

ข้อดีอย่างเดียวที่ฉันเห็นคือเมื่อตัววนซ้ำลำดับส่งคืนการอ้างอิงพร็อกซีและคุณต้องดำเนินการกับการอ้างอิงนั้นในลักษณะที่ไม่ใช่ const ตัวอย่างเช่นพิจารณา:

#include <vector>

int main()
{
    std::vector<bool> v(10);
    for (auto& e : v)
        e = true;
}

สิ่งนี้ไม่ได้รวบรวมเนื่องจาก rvalue vector<bool>::referenceส่งคืนจากiteratorจะไม่ผูกกับการอ้างอิง lvalue ที่ไม่ใช่ const แต่จะได้ผล:

#include <vector>

int main()
{
    std::vector<bool> v(10);
    for (auto&& e : v)
        e = true;
}

ทั้งหมดที่กล่าวมาฉันจะไม่เขียนโค้ดแบบนี้เว้นแต่คุณจะรู้ว่าคุณจำเป็นต้องใช้ในกรณีนี้ คือผมจะไม่ทำเช่นนี้ไม่จำเป็นเพราะมันจะทำให้คนที่น่าแปลกใจในสิ่งที่คุณกำลังขึ้นไป และถ้าฉันทำมันก็ไม่เจ็บที่จะรวมความคิดเห็นว่าทำไม:

#include <vector>

int main()
{
    std::vector<bool> v(10);
    // using auto&& so that I can handle the rvalue reference
    //   returned for the vector<bool> case
    for (auto&& e : v)
        e = true;
}

แก้ไข

กรณีสุดท้ายของฉันนี้ควรเป็นแม่แบบที่สมเหตุสมผล ถ้าคุณรู้ว่าห่วงอยู่เสมอจัดการอ้างอิงพร็อกซี่แล้วจะทำงานเช่นเดียวกับauto auto&&แต่เมื่อบางครั้งลูปจัดการการอ้างอิงที่ไม่ใช่พร็อกซีและบางครั้งการอ้างอิงพร็อกซีฉันคิดว่าauto&&จะกลายเป็นทางออกที่เลือกได้

การใช้auto&&หรือการอ้างอิงแบบสากลกับfor-loop ตามช่วงมีข้อดีที่คุณจะจับสิ่งที่คุณได้รับ สำหรับชนิดมากที่สุดของ iterators คุณอาจจะได้รับอย่างใดอย่างหนึ่งT&หรือสำหรับบางชนิดT const& Tกรณีที่น่าสนใจคือการอ้างอิงตัววนซ้ำจะให้ผลชั่วคราว: C ++ 2011 มีข้อกำหนดที่ผ่อนคลายและตัวทำซ้ำไม่จำเป็นต้องให้ค่า lvalue การใช้การอ้างอิงสากลตรงกับการส่งต่ออาร์กิวเมนต์ในstd::for_each():

template <typename InIt, typename F>
F std::for_each(InIt it, InIt end, F f) {
    for (; it != end; ++it) {
        f(*it); // <---------------------- here
    }
    return f;
}

วัตถุฟังก์ชั่นfสามารถรักษาT&, T const&และTแตกต่างกัน เหตุใดเนื้อความของลูปตามช่วงจึงควรforแตกต่างกัน แน่นอนในการใช้ประโยชน์จากการอนุมานประเภทโดยใช้การอ้างอิงสากลคุณต้องส่งต่อไปตามลำดับ:

for (auto&& x: range) {
    f(std::forward<decltype(x)>(x));
}

แน่นอนว่าการใช้std::forward()หมายความว่าคุณยอมรับค่าที่ส่งคืนที่จะย้ายจาก วัตถุเช่นนี้เหมาะสมหรือไม่ในโค้ดที่ไม่ใช่เทมเพลตที่ฉันไม่รู้ (ยัง?) ฉันสามารถจินตนาการได้ว่าการใช้การอ้างอิงที่เป็นสากลสามารถให้ข้อมูลเพิ่มเติมแก่คอมไพเลอร์เพื่อทำสิ่งที่ถูกต้องได้ ในโค้ดเทมเพลตจะไม่ต้องตัดสินใจว่าจะเกิดอะไรขึ้นกับวัตถุ

auto&&ฉันแทบมักจะใช้ ทำไมถึงโดนกัดโดย edge case ในเมื่อไม่ต้องทำ? พิมพ์สั้นกว่าด้วยและฉันก็พบว่ามันมากกว่า ... โปร่งใส เมื่อคุณใช้auto&& xแล้วคุณจะรู้ว่าที่xแน่นอน*itทุกครั้ง