Was ist der Vorteil der Verwendung von Weiterleitungsreferenzen in bereichsbasierten for-Schleifen?

const auto&würde ausreichen, wenn ich schreibgeschützte Operationen ausführen möchte. Ich bin jedoch darauf gestoßen

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

ein paar Mal in letzter Zeit. Das wundert mich:

Ist es möglich, dass in einigen dunklen Eckfällen die Verwendung von Weiterleitungsreferenzen im Vergleich zu auto&oder einen gewissen Leistungsvorteil bietet const auto&?

( shared_ptrist ein Verdächtiger für obskure Eckfälle)

Update Zwei Beispiele, die ich in meinen Favoriten gefunden habe:

Gibt es einen Nachteil bei der Verwendung von const-Referenzen beim Durchlaufen von Basistypen?
Kann ich die Werte einer Karte mithilfe einer bereichsbasierten for-Schleife problemlos durchlaufen?

Bitte konzentrieren Sie sich auf die Frage: Warum sollte ich auto && in bereichsbasierten for-Schleifen verwenden?

Der einzige Vorteil, den ich sehen kann, ist, wenn der Sequenziterator eine Proxy-Referenz zurückgibt und Sie diese Referenz auf eine nicht konstante Weise bearbeiten müssen. Betrachten Sie zum Beispiel:

#include <vector>

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

Dies lässt sich nicht kompilieren , weil rvalue vector<bool>::referenceaus der zurück iteratorwird lvalue Referenz nicht binden an eine nicht-const. Aber das wird funktionieren:

#include <vector>

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

Abgesehen davon würde ich nicht so codieren, wenn Sie nicht wüssten, dass Sie einen solchen Anwendungsfall erfüllen müssen. Dh ich würde dies grundlos nicht tun , weil es tut Ursache Menschen zu fragen , was Sie vorhaben. Und wenn ich es tun würde, würde es nicht schaden, einen Kommentar dazu aufzunehmen, warum:

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

Bearbeiten

Dieser letzte Fall von mir sollte wirklich eine Vorlage sein, um Sinn zu machen. Wenn Sie wissen, dass die Schleife immer eine Proxy-Referenz verarbeitet, autofunktioniert dies genauso gut wie auto&&. Aber wenn die Schleife manchmal Nicht-Proxy-Referenzen und manchmal Proxy-Referenzen handhabte, dann würde ich denke auto&&, die Lösung der Wahl werden.

Die Verwendung von auto&&oder universellen Referenzen mit einer forbereichsbasierten Schleife hat den Vorteil, dass Sie erfassen, was Sie erhalten. Für die meisten Arten von Iteratoren erhalten Sie wahrscheinlich entweder einen T&oder einen T const&für einen Typ T. Der interessante Fall ist, wenn die Dereferenzierung eines Iterators eine temporäre ergibt: C ++ 2011 hat entspannte Anforderungen und Iteratoren müssen nicht unbedingt einen l-Wert liefern. Die Verwendung universeller Referenzen entspricht der Argumentweiterleitung in 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;
}

Das Funktionsobjekt fkann behandeln T&, T const&und Tanders. Warum sollte der Körper einer forbereichsbasierten Schleife anders sein? Um den Typ tatsächlich unter Verwendung universeller Referenzen ableiten zu können, müssen Sie sie natürlich entsprechend weitergeben:

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

Verwenden std::forward()bedeutet natürlich, dass Sie alle zurückgegebenen Werte akzeptieren, aus denen verschoben werden soll. Ob solche Objekte in Nicht-Vorlagencode viel Sinn machen, weiß ich (noch?) Nicht. Ich kann mir vorstellen, dass die Verwendung universeller Referenzen dem Compiler mehr Informationen bieten kann, um das Richtige zu tun. Im Vorlagencode wird keine Entscheidung darüber getroffen, was mit den Objekten geschehen soll.

Ich benutze praktisch immer auto&&. Warum von einem Randfall gebissen werden, wenn Sie nicht müssen? Es ist auch kürzer zu tippen und ich finde es einfach ... transparenter. Wenn Sie verwenden auto&& x, wissen Sie jedes Mal xgenau *it, dass .