Was ist der Vorteil der Verwendung von forwarding-Referenzen in range-basierte for-Schleifen?

const auto& würde genügen, wenn ich möchte nur-lese-Operationen. Ich habe allerdings stieß in

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

ein paar mal vor kurzem. Das macht mich Frage mich:

Ist es möglich, dass in einigen obskuren Ecke Fälle gibt es einige performance-Vorteil in der Verwendung von forwarding-Referenzen im Vergleich zu auto& oder const auto&?

(shared_ptr ist ein Verdächtiger für die obskuren Ecke Fälle)

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

Jeder Nachteil der Verwendung von const-Referenz bei der Iteration über die grundlegenden Typen?

Kann ich problemlos Durchlaufen, die Werte einer map mit einem range-basierte for-Schleife?

Bitte konzentrieren sich auf die Frage: warum würde ich wollen, verwenden Sie den auto&& in die range-basierte for-Schleifen?

Tun Sie wirklich sehen, dass es "oft"?
Ich bin mir nicht sicher, es gibt genug Kontext, in Ihrer Frage für mich um zu Messen, wie "verrückt" es ist, wo Sie sind, es zu sehen.
Lange Rede, kurzer Sinn: warum würde ich wollen, verwenden Sie auto&& im range-basierte for-Schleifen?

InformationsquelleAutor Ali | 2012-10-29

c++c++11 for-loop move-semantics performance

85

Der einzige Vorteil, den ich sehen kann, ist, wenn die Sequenz iterator liefert eine proxy-Referenz, und Sie müssen auf die Referenz in einer nicht-const Weg. Zum Beispiel:
```
#include <vector>

int main()
{
    std::vector<bool> v(10);
    for (auto& e : v)
        e = true;
}
```
Diese nicht kompilieren, da rvalue vector<bool>::reference zurückgegeben, die von der iterator nicht eine Bindung an eine nicht-const lvalue reference. Aber dies funktioniert:
```
#include <vector>

int main()
{
    std::vector<bool> v(10);
    for (auto&& e : v)
        e = true;
}
```
Alle, die being said, ich würde nicht code dieser Art, es sei denn, Sie wussten, dass Sie benötigt, um zu erfüllen, solch ein Anwendungsfall. I. e. Würde ich nicht tun dies unentgeltlich, weil es hat dazu führen, Menschen zu Fragen, was du vorhast. Und wenn ich es tun, es würde nicht Schaden, um einen Kommentar, 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

Diesem letzten Fall der mine sollte wirklich eine Vorlage, um Sinn zu machen. Wenn Sie wissen, die Schleife ist immer Umgang mit einem proxy-Referenz, dann auto funktionieren würde, sowie auto&&. Aber wenn die Schleife war manchmal die Verarbeitung von nicht-proxy-Referenzen und manchmal proxy-Referenzen, dann denke ich auto&& wäre die Lösung der Wahl.
- Auf der anderen Seite, es gibt keine explizite Nachteil, ist es? (Abgesehen von möglicherweise verwirrenden Menschen, die ich glaube nicht, dass ist viel Wert, zu erwähnen, persönlich.)
- Das ist ein interessanter Punkt. Vermutlich gibt es keine Möglichkeit, die Förderung Bereichs-for zu bevorzugen T::const_iterator? Ich glaube begin() und end() verwendet werden. Scheint ein bisschen wie ein versehen, außer der, die Sie verwenden können rvalue Referenzen. Also ja vielleicht ist das die Antwort.
- Ein anderer Begriff für das schreiben von code, dass unnötig Menschen verwirrt ist: schreiben confuscated code. Es ist am besten, um Ihren code so einfach wie möglich-aber nicht einfacher. Dies wird helfen, die bug-count-down. That being said, da && vertrauter wird, dann vielleicht in 5 Jahren die Leute kommen zu erwarten, dass ein auto&& idiom (vorausgesetzt es ist tatsächlich nicht Schaden). Ich weiß nicht, ob das passieren wird oder nicht. Aber einfach liegt im Auge des Betrachters, und wenn Sie schreiben, für mehr als nur sich selbst, nehmen Ihre Leser zu berücksichtigen.
- Ich bevorzuge const auto& wenn ich will, dass der compiler helfen Sie mir zu überprüfen, dass ich nicht versehentlich ändern Sie die Elemente in der Sequenz.
- T> T const& as_const(const T& v){ return v; } und for(auto& e : as_const(v)) ....
- Ah, aber const T::iterator ist nicht T::const_iterator, richtig? d.h. nicht, dass tatsächlich in diesem Fall? Ich nehme an, das ist eine andere Frage. Sieht aus wie "ja", aber ich weiß nicht, warum.
- Ich persönlich benutze gerne auto&& im generischen code wo muss ich zum ändern der Elemente der Sequenz. Wenn ich nicht, ich werde nur stick auto const&.
- Es ist, weil von Enthusiasten wie dich, ständig zu Experimentieren und drängen nach besseren Möglichkeiten, Dinge zu tun, dass C++ entwickelt sich ständig weiter. Danke. 🙂
- delegieren den Aufruf Mitglied begin, die überlastet ist auf const.
- Warum nicht auto&& e eine rvalue ist und deshalb auch nicht möglich, zugeordnet werden? es ist buchstäblich, die auf der linken Seite..
- 7. Absatz dieses Abschnitts: open-std.org/jtc1/sc22/wg21/docs/papers/2002/... ", obwohl Namen rvalue-Referenzen ..."
- danke, ich möchte beobachtete Sie eine Präsentation von Scott Meyers über diese, und es war ungemein hilfreich, mit diesem und Realisierung ich würde missverstanden rvalue vs rvalue-Referenz. Ich verstehe nicht, warum universal-Referenzen waren nicht eigentlich eine andere Sache, Teil der Norm mit einem neuen token wie &&&?
- Es war ein Urteil-Aufruf gemacht in der Zeit: Töten Sie zwei Vögel mit einem Stein.
- Die top-Beispiel kompiliert nur Ordnung in VS2015u2.
- Mit Warnungen auf, es sagt, es wird eine Erweiterung zu kompilieren. Es ist eine gefährliche Erweiterung, deren hauptsächliche Verwendung ist die rückwärts-Kompatibilität mit pre-C++98 code.
- halten würde, was die Erweiterung eigentlich? cheat auto& in auto&& hinter unserem Rücken?
- Ich weiß es nicht wirklich. Fast alles, was ich weiß über die VS, ich sammle von hier: webcompiler.cloudapp.net
- "[...] dann vielleicht in 5 Jahren die Leute kommen zu erwarten, dass ein auto&& idiom [...]" 7 Jahre später für den(auto&& x : y) ist immer noch sehr verwirrend und definitiv nicht erwartet idiom.
InformationsquelleAutor Howard Hinnant
25

Mit auto&& oder universal-Referenzen mit einem range-basierte for-Schleife hat den Vorteil, dass Sie erfasst, was Sie bekommen. Für die meisten Arten von Iteratoren werden Sie wahrscheinlich entweder eine T& oder eine T const& für irgendeine Art T. Der interessante Fall ist, wo die Dereferenzierung einen iterator liefert einen temporären: C++ 2011 lockerte Anforderungen und Iteratoren sind nicht unbedingt erforderlich, um Ertrag ein lvalue. Die Verwendung von universal-Referenzen entspricht das argument der Weiterleitung 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;
}
```
Die Funktion Objekt f behandeln können T&, T const&, und T anders. Warum sollte der Körper eines range-basierte for-Schleife anders sein? Natürlich, um tatsächlich den Vorteil ableiten, die die Art der Nutzung von universal Verweise müssten Sie passieren Ihnen auf dem sinngemäß:
```
for (auto&& x: range) {
    f(std::forward<decltype(x)>(x));
}
```
Natürlich mit std::forward() bedeutet, dass Sie akzeptieren alle zurückgegebenen Werte bewegt werden, aus. Ob Objekte wie das macht viel Sinn in der nicht-template-code, weiß ich nicht (noch nicht?). Ich kann mir vorstellen, dass die Verwendung von universal-Referenzen bieten können weitere Informationen an den compiler, das Richtige zu tun. In der Vorlagen-code bleibt es aus für die Entscheidung auf das, was passieren soll mit den Objekten.

InformationsquelleAutor Dietmar Kühl
7

Ich praktisch immer verwenden auto&&. Warum gebissen durch eine Kante, wenn Sie nicht müssen? Es ist kürzer, um zu geben, und ich finde einfach es mehr... transparent. Wenn Sie auto&& x, dann wissen Sie, dass x ist genau *it jeder Zeit.
- Mein problem ist, dass Ihr aufgeben const-ness mit auto&& wenn const auto& genügt. Die Frage fragt nach der Ecke Fälle, wo ich kann, gebissen zu werden. Was sind die Ausnahmefälle, die nicht erwähnt wurden von Dietmar oder Howard noch?
- Hier ist ein Weg, um gebissen zu werden, wenn Sie do verwenden auto&&. Wenn der Typ, den Sie erfassen sollte verschoben werden in den Körper der Schleife (zum Beispiel), und wird sich zu einem späteren Zeitpunkt, damit es behebt einen const& geben, Ihr code wird automatisch weiter funktionieren, aber Ihre Bewegungen werden kommen Kopien. Dieser code wird sehr trügerisch sein. Wenn du allerdings explizit die Art als r-value-Referenz, wer verändert die container geben wird, erhalten Sie einen Kompilierungsfehler, da Sie wirklich, wirklich wollte diese Objekte verschoben und nicht kopiert...
- Ich kam gerade über diese: wie kann ich erzwingen eine rvalue-Referenz, ohne dabei explizit den Typ angeben? So etwas wie for (std::decay_t<decltype(*v.begin())>&& e: v)? Ich denke, es gibt einen besseren Weg ...
- Es hängt davon ab, was Sie auf do wissen über den Typ. Wie oben erwähnt, auto&& geben wird, eine "universal-Referenz", also alles andere als, die erhalten Sie einen spezifischeren Typ. Wenn v wird davon ausgegangen, dass ein vector Sie tun konnte decltype(v)::value_type&&, das ist, was ich nehme an, Sie wollten durch die Einnahme das Ergebnis der operator* auf einen iterator geben. Sie können auch decltype(begin(v))::value_type&& zu überprüfen, die iterator-Typen anstelle des Containers. Wenn wir so wenig Einblick in die Art, obwohl, wir könnten es ein wenig klarer, nur mit auto&&...
InformationsquelleAutor Puppy

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.