Range-based for loop (since C++11)

Führt eine for -Schleife über einen Bereich aus.

Wird als besser lesbares Äquivalent zur traditionellen for Schleife verwendet, die über einen Wertebereich operiert, wie beispielsweise alle Elemente in einem Container.

Syntax

Erklärung

Die obige Syntax erzeugt Code, der dem Folgenden entspricht außer der Lebensdauerverlängerung von Temporaries des range-initializer (siehe unten ) (since C++23) (die Variablen und Ausdrücke in /* */ sind nur zur Veranschaulichung):

range-initializer wird ausgewertet, um die Sequenz oder den Bereich für die Iteration zu initialisieren. Jedes Element der Sequenz wird wiederum dereferenziert und dazu verwendet, die Variable mit dem in item-declaration angegebenen Typ und Namen zu initialisieren.

item-declaration kann eines der folgenden sein:

• eine einfache Deklaration mit folgenden Einschränkungen:
• Sie hat nur einen Deklarator .
• Der Deklarator darf keinen Initialisierer haben.
• Die Deklarationsspezifizierer-Sequenz darf nur Typspezifizierer und constexpr enthalten und kann keine Klasse oder Enumeration definieren.

Nur-Darstellungsausdrücke /* begin-expr */ und /* end-expr */ werden wie folgt definiert:

• Wenn der Typ von /* range */ ein Verweis auf einen Array-Typ R ist:

• Wenn R ein Array mit fester Größe N ist, /* begin-expr */ ist /* range */ und /* end-expr */ ist /* range */ + N .
• Wenn R ein Array mit unbekannter Größe oder ein Array mit unvollständigem Typ ist, ist das Programm fehlerhaft.

• Wenn der Typ von /* range */ eine Referenz auf einen Klassentyp C ist, und die Suche im Gültigkeitsbereich von C nach den Namen " begin " und " end " jeweils mindestens eine Deklaration findet, dann ist /* begin-expr */ gleich /* range */ . begin ( ) und /* end-expr */ ist gleich /* range */ . end ( ) .
• Andernfalls ist /* begin-expr */ gleich begin ( /* range */ ) und /* end-expr */ ist gleich end ( /* range */ ) , wobei " begin " und " end " mittels argument-dependent lookup gefunden werden (non-ADL lookup wird nicht durchgeführt).

Wenn die Schleife innerhalb der statement beendet werden muss, kann eine break statement als abschließende Anweisung verwendet werden.

Wenn die aktuelle Iteration innerhalb der Anweisung beendet werden muss, kann eine continue Anweisung als Abkürzung verwendet werden.

Wenn ein Name, der in der init-statement eingeführt wird, im äußersten Block der statement erneut deklariert wird, ist das Programm fehlerhaft:

for (int i : {1, 2, 3})
    int i = 1; // Fehler: Neudeklaration

Temporärer Bereichsinitialisierer

Wenn der range-initializer ein temporäres Objekt zurückgibt, wird seine Lebensdauer bis zum Ende der Schleife verlängert, wie durch die Bindung an die Weiterleitungsreferenz /* range */ angezeigt.

Die Lebensdauern aller Temporaries innerhalb des range-initializer werden nicht verlängert es sei denn, sie würden sonst am Ende des range-initializer zerstört werden (since C++23) .

// wenn foo() als Wert zurückgibt
for (auto& x : foo().items()) { /* ... */ } // bis C++23 undefiniertes Verhalten

for (T thing = foo(); auto& x : thing.items()) { /* ... */ } // OK

using T = std::list<int>;
const T& f1(const T& t) { return t; }
const T& f2(T t)        { return t; } // always returns a dangling reference
T g();
void foo()
{
    for (auto e : f1(g())) {} // OK: lifetime of return value of g() extended
    for (auto e : f2(g())) {} // UB: lifetime of f2's value parameter ends early
}

Hinweise

Wenn der range-initializer eine geschweifte Klammer-Initialisierungsliste ist, /* range */ wird als Referenz auf ein std::initializer_list abgeleitet.

Es ist sicher und in der Tat in generischem Code vorzuziehen, Deduktion für Forwarding-Referenzen zu verwenden, for ( auto && var : sequence ) .

Die Member-Interpretation wird verwendet, wenn der Bereichstyp einen Member namens " begin " und einen Member namens " end " besitzt. Dies erfolgt unabhängig davon, ob der Member ein Typ, ein Datenmember, eine Funktion oder ein Enumerator ist, und unabhängig von seiner Zugänglichkeit. Daher kann eine Klasse wie class meow { enum { begin = 1 , end = 2 } ; /* rest of class */ } ; nicht mit der bereichsbasierten for -Schleife verwendet werden, selbst wenn die namespace-weiten " begin "/" end "-Funktionen vorhanden sind.

Während die in der item-declaration deklarierte Variable normalerweise in der statement verwendet wird, ist dies nicht zwingend erforderlich.

Bei Verwendung mit einem (nicht-konstanten) Objekt, das Copy-on-Write-Semantik besitzt, kann die bereichsbasierte for Schleife ein tiefes Kopieren auslösen, indem sie (implizit) die nicht-konstante begin() Memberfunktion aufruft.

struct cow_string { /* ... */ }; // a copy-on-write string
cow_string str = /* ... */;
// for (auto x : str) { /* ... */ } // may cause deep copy
for (auto x : std::as_const(str)) { /* ... */ }

Schlüsselwörter

for

Beispiel

#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v = {0, 1, 2, 3, 4, 5};
    for (const int& i : v) // Zugriff per const-Referenz
        std::cout << i << ' ';
    std::cout << '\n';
    for (auto i : v) // Zugriff per Wert, der Typ von i ist int
        std::cout << i << ' ';
    std::cout << '\n';
    for (auto&& i : v) // Zugriff per Forwarding-Referenz, der Typ von i ist int&
        std::cout << i << ' ';
    std::cout << '\n';
    const auto& cv = v;
    for (auto&& i : cv) // Zugriff per Forwarding-Referenz, der Typ von i ist const int&
        std::cout << i << ' ';
    std::cout << '\n';
    for (int n : {0, 1, 2, 3, 4, 5}) // Der Initialisierer kann eine
                                     // geschweifte Initialisierungsliste sein
        std::cout << n << ' ';
    std::cout << '\n';
    int a[] = {0, 1, 2, 3, 4, 5};
    for (int n : a) // Der Initialisierer kann ein Array sein
        std::cout << n << ' ';
    std::cout << '\n';
    for ([[maybe_unused]] int n : a)  
        std::cout << 1 << ' '; // Die Schleifenvariable muss nicht verwendet werden
    std::cout << '\n';
    for (auto n = v.size(); auto i : v) // Die Init-Anweisung (C++20)
        std::cout << --n + i << ' ';
    std::cout << '\n';
    for (typedef decltype(v)::value_type elem_t; elem_t i : v)
    // Typdefinition als Init-Anweisung (C++20)
        std::cout << i << ' ';
    std::cout << '\n';
    for (using elem_t = decltype(v)::value_type; elem_t i : v)
    // Alias-Deklaration als Init-Anweisung (C++23)
        std::cout << i << ' ';
    std::cout << '\n';
}

0 1 2 3 4 5 
0 1 2 3 4 5 
0 1 2 3 4 5 
0 1 2 3 4 5 
0 1 2 3 4 5 
0 1 2 3 4 5 
1 1 1 1 1 1 
5 5 5 5 5 5 
0 1 2 3 4 5 
0 1 2 3 4 5

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch