Apa keuntungan menggunakan referensi penerusan dalam loop berbasis rentang?

const auto&sudah cukup jika saya ingin melakukan operasi hanya-baca. Namun, saya telah bertemu

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

beberapa kali baru-baru ini. Ini membuat saya bertanya-tanya:

Mungkinkah dalam beberapa kasus sudut yang tidak jelas ada beberapa manfaat kinerja dalam menggunakan referensi penerusan, dibandingkan dengan auto&atau const auto&?

( shared_ptradalah tersangka untuk kasus sudut yang tidak jelas)

Perbarui Dua contoh yang saya temukan di favorit saya:

Adakah kerugian menggunakan referensi const saat melakukan iterasi pada tipe dasar?
Dapatkah saya dengan mudah mengulang nilai peta menggunakan for loop berbasis rentang?

Harap konsentrasikan pada pertanyaan: mengapa saya ingin menggunakan auto && in range-based for loop?

Satu-satunya keuntungan yang bisa saya lihat adalah ketika iterator urutan mengembalikan referensi proxy dan Anda perlu mengoperasikan referensi itu dengan cara non-const. Misalnya pertimbangkan:

#include <vector>

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

Ini tidak dapat dikompilasi karena rvalue yang vector<bool>::referencedikembalikan dari iteratortidak akan mengikat ke referensi lvalue non-const. Tapi ini akan berhasil:

#include <vector>

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

Semua yang dikatakan, saya tidak akan membuat kode dengan cara ini kecuali Anda tahu Anda perlu memenuhi kasus penggunaan seperti itu. Yaitu saya tidak akan melakukan ini cuma-cuma karena tidak menyebabkan orang bertanya-tanya apa yang Anda lakukan. Dan jika saya melakukannya, tidak ada salahnya untuk menyertakan komentar mengapa:

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

Sunting

Kasus terakhir saya ini harus benar-benar menjadi template yang masuk akal. Jika Anda tahu bahwa loop selalu menangani referensi proxy, maka itu autoakan berfungsi dengan baik auto&&. Tetapi ketika loop terkadang menangani referensi non-proxy dan terkadang referensi proxy, maka saya pikir auto&&akan menjadi solusi pilihan.

Menggunakan auto&&atau referensi universal dengan range-based for-loop memiliki keuntungan bahwa Anda menangkap apa yang Anda dapatkan. Untuk sebagian besar jenis iterator, Anda mungkin akan mendapatkan a T&atau a T const&untuk beberapa jenis T. Kasus yang menarik adalah di mana dereferensi sebuah iterator menghasilkan sementara: C ++ 2011 mendapatkan persyaratan yang lebih longgar dan iterator tidak selalu diperlukan untuk menghasilkan nilai l. Penggunaan referensi universal cocok dengan penerusan argumen di 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;
}

Fungsi objek fdapat mengobati T&, T const&dan Tberbeda. Mengapa body dari range-based for-loop berbeda? Tentu saja, untuk benar-benar memanfaatkan hasil deduksi tipe menggunakan referensi universal, Anda harus meneruskannya sesuai:

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

Tentu saja, menggunakan std::forward()cara yang Anda terima dari nilai yang dikembalikan untuk dipindahkan. Apakah objek seperti ini masuk akal dalam kode non-template, saya belum tahu (belum?). Saya dapat membayangkan bahwa menggunakan referensi universal dapat menawarkan lebih banyak informasi kepada kompiler untuk melakukan Hal yang Benar. Dalam kode templated, ia tidak membuat keputusan apa pun tentang apa yang harus terjadi dengan objek.

Saya hampir selalu menggunakan auto&&. Mengapa digigit oleh kasus tepi saat Anda tidak perlu? Ini juga lebih pendek untuk diketik, dan saya merasa lebih ... transparan. Saat Anda menggunakan auto&& x, maka Anda tahu xpersis *it, setiap saat.