Namespaces
Variants

    std::ranges::iota_view<W, Bound>::iterator

    Aus de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Bereichsadapter
     
    std::ranges::iota_view
    Mitgliedsfunktionen
    Ableitungsregeln
    Verschachtelte Klassen
    Iterator
    Hilfskonzepte
    Mitgliedstypen
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
    Sentinel
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
     
    struct /*iterator*/;
    		(1) (nur zur Veranschaulichung*)
    Hilfsaliasvorlagen
    		 
    template< class I >
using /*iota-diff-t*/ = /* see below */;
    		(2) (nur zur Veranschaulichung*)
    Hilfskonzepte
    		 
    template< class I >
concept /*decrementable*/ =
    std::incrementable<I> && requires(I i)
    {
        { --i } -> std::same_as<I&>;
        { i-- } -> std::same_as<I>;
    };
    		(3) (nur zur Veranschaulichung*) 
    template< class I >
concept /*advanceable*/ =
    /*decrementable*/<I> && std::totally_ordered<I> &&
    requires(I i, const I j, const /*iota-diff-t*/<I> n)
    {
        { i += n } -> std::same_as<I&>;
        { i -= n } -> std::same_as<I&>;
        I(j + n);
        I(n + j);
        I(j - n);
        { j - j } -> std::convertible_to</*iota-diff-t*/<I>>;
    };
    		(4) (nur zur Veranschaulichung*)
    1) ranges::iota_view<W, Bound>::iterator ist der Typ der Iteratoren, die von begin() und end() von ranges::iota_view<W, Bound>.
    2) Berechnet den Differenztyp für beide Iterator-Typen und ganzzahlartige Typen.
    • Falls I kein integraler Typ ist, oder falls es ein integraler Typ ist und sizeof(std::iter_difference_t<I>) größer als sizeof(I) ist, dann ist /*iota-diff-t*/<I> std::iter_difference_t<I>.
    • Andernfalls ist /*iota-diff-t*/<I> ein vorzeichenbehafteter Integer-Typ mit einer Breite größer als die Breite von I, falls ein solcher Typ existiert.
    • Andernfalls ist I einer der breitesten integralen Typen, und /*iota-diff-t*/<I> ist ein unspezifizierter vorzeichenbehafteter ganzzahlartiger Typ mit einer Breite nicht kleiner als die Breite von I. Es ist unspezifiziert, ob /*iota-diff-t*/<I> weakly_incrementable in diesem Fall modelliert.
    3) Gibt an, dass ein Typ incrementable ist, und dass Prä- und Post- operator-- für den Typ eine gemeinsame Bedeutung haben.
    4) Gibt an, dass ein Typ sowohl decrementable als auch totally_ordered ist, und dass operator+=, operator-=, operator+ und operator- zwischen dem Typ und seinem unterschiedlichen Typ eine gemeinsame Bedeutung haben.

    /*iterator*/ modelliert

    Allerdings erfüllt es nur LegacyInputIterator falls W modelliert incrementable, und erfüllt LegacyInputIterator andernfalls nicht.

    Semantische Anforderungen

    3) Typ I modelliert decrementable nur dann, wenn I decrementable erfüllt und alle davon subsumierten Konzepte modelliert werden, und für gleiche Objekte a und b vom Typ I :
    • Wenn a und b im Definitionsbereich sowohl von Prä- als auch Post- operator -- liegen (d.h. sie sind dekrementierbar), dann sind alle folgenden Ausdrücke true :
    • Wenn a und b im Definitionsbereich sowohl von Prä- als auch Post- operator ++ liegen (d.h. sie sind inkrementierbar), dann ist bool ( -- ( ++ a ) == b ) true .
    4) Let D denote /*iota-diff-t*/ < I > . Type I models advanceable only if I satisfies advanceable and all concepts it subsumes are modeled, and given
    • Objekte a und b vom Typ I und
    • Wert n vom Typ D ,

    so dass b von a nach n Anwendungen von ++ a erreichbar ist, alle folgenden Bedingungen erfüllt sind:

    • ( a + = n ) entspricht b .
    • std:: addressof ( a + = n ) ist gleich std:: addressof ( a ) .
    • I ( a + n ) entspricht ( a + = n ) .
    • Für zwei beliebige positive Werte x und y vom Typ D , falls I ( a + D ( x + y ) ) wohldefiniert ist, dann ist I ( a + D ( x + y ) ) gleich I ( I ( a + x ) + y ) .
    • I ( a + D ( 0 ) ) ist gleich a .
    • Wenn I ( a + D ( n - 1 ) ) wohldefiniert ist, dann ist I ( a + n ) gleich [ ] ( I c ) { return ++ c ; } ( I ( a + D ( n - 1 ) ) ) .
    • ( b + = - n ) entspricht a .
    • ( b - = n ) entspricht a .
    • std:: addressof ( b - = n ) ist gleich std:: addressof ( b ) .
    • I ( b - n ) ist gleich ( b - = n ) .
    • D ( b - a ) ist gleich n .
    • D ( a - b ) ist gleich D ( - n ) .
    • bool ( a <= b ) ist true .

    Verschachtelte Typen

    Typ Definition
    iterator_concept ein Iterator-Tag , siehe unten
    iterator_category
    (nur vorhanden, wenn W das Konzept incrementable modelliert und
    /*iota-diff-t*/ < W > ein integraler Typ ist)     		std::input_iterator_tag
    value_type W
    difference_type /*iota-diff-t*/ < W >

    Bestimmung des Iterator-Konzepts

    iterator_concept ist wie folgt definiert:

    Datenelemente

    Element Beschreibung
    W value_ der aktuelle Wert
    (nur zur Darstellung Elementobjekt*)

    Memberfunktionen

    std::ranges::iota_view:: iterator :: iterator

    /*iterator*/ ( ) requires std:: default_initializable < W > = default ;
    		(1) (seit C++20)
    constexpr explicit /*iterator*/ ( W value ) ;
    		(2) (seit C++20)
    1) Wertinitialisiert value_ .
    2) Initialisiert value_ mit value .

    std::ranges::iota_view:: iterator :: operator*

    constexpr W operator * ( ) const
    noexcept ( std:: is_nothrow_copy_constructible_v < W > ) ;
    		(seit C++20)

    Gibt value_ zurück.

    Beispiel

    Diesen Code ausführen 
    #include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6, 9).begin()};
    const int& r = *it; // bindet an temporäres Objekt
    assert(*it == 6 and r == 6);
    ++it;
    assert(*it == 7 and r == 6);
}
    **Übersetzte Elemente:** - "since C++20" → "seit C++20" - "Returns" → "Gibt" - "Example" → "Beispiel" - "Run this code" → "Diesen Code ausführen" - "binds with temporary" → "bindet an temporäres Objekt" **Nicht übersetzte Elemente:** - Alle HTML-Tags und Attribute - Code innerhalb der ``, `
    ` und `` Tags
- C++-spezifische Begriffe wie `constexpr`, `noexcept`, `operator*`, `const`, `assert`, etc.
- Technische Bezeichnungen wie `value_`

    std::ranges::iota_view:: iterator :: operator++

    constexpr /*iterator*/ & operator ++ ( ) ;
    		(1) (seit C++20)
    constexpr void operator ++ ( int ) ;
    		(2) (seit C++20)
    constexpr /*iterator*/ operator ++ ( int ) requires std:: incrementable < W > ;
    		(3) (seit C++20)
    1) Entspricht ++ value_  ; return * this ; .
    2) Entspricht ++ value_  ; .
    3) Entspricht auto tmp = * this ; ++ value_  ; return tmp ; .

    Beispiel

    Code ausführen 
    #include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(8).begin()};
    assert(*it == 8);
    assert(*++it == 9);
    assert(*it++ == 9);
    assert(*it == 10);
}

    std::ranges::iota_view:: iterator :: operator--

    constexpr /*iterator*/ & operator -- ( ) requires /*decrementable*/ < W > ;
    		(1) (seit C++20)
    constexpr /*iterator*/ operator -- ( int ) requires /*decrementable*/ < W > ;
    		(2) (seit C++20)
    1) Entspricht -- value_  ; return * this ; .
    2) Entspricht auto tmp = * this ; -- value_  ; return tmp ; .

    Beispiel

    Code ausführen 
    #include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(8).begin()};
    assert(*it == 8);
    assert(*--it == 7);
    assert(*it-- == 7);
    assert(*it == 6);
}

    std::ranges::iota_view:: iterator :: operator+=

    constexpr /*iterator*/ & operator + = ( difference_type n )
    requires /*advanceable*/ < W > ;
    		(seit C++20)

    Aktualisiert value_ und gibt * this zurück:

    Beispiel

    Code ausführen 
    #include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(5).begin()};
    assert(*it == 5);
    assert(*(it += 3) == 8);
}

    std::ranges::iota_view:: iterator :: operator-=

    constexpr /*iterator*/ & operator - = ( difference_type n )
    requires /*advanceable*/ < W > ;
    		(seit C++20)

    Aktualisiert value_ und gibt * this zurück:

    Beispiel

    Code ausführen 
    #include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it -= -3) == 9);
}

    std::ranges::iota_view:: iterator :: operator[]

    constexpr W operator [ ] ( difference_type n ) const
    requires /*advanceable*/ < W > ;
    		(seit C++20)

    Gibt W ( value_ + n ) zurück.

    Beispiel

    Code ausführen 
    #include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it + 3) == 9);
}

    Nicht-Member-Funktionen

    operator==, <, >, <=, >=, <=> (std::ranges::iota_view:: iterator )

    friend constexpr bool operator ==

    ( const /*iterator*/ & x, const /*iterator*/ & y )

    requires std:: equality_comparable < W > ;
    		(1) (seit C++20)
    friend constexpr bool operator <

    ( const /*iterator*/ & x, const /*iterator*/ & y )

    requires std:: totally_ordered < W > ;
    		(2) (seit C++20)
    friend constexpr bool operator >

    ( const /*iterator*/ & x, const /*iterator*/ & y )

    requires std:: totally_ordered < W > ;
    		(3) (seit C++20)
    friend constexpr bool operator <=

    ( const /*iterator*/ & x, const /*iterator*/ & y )

    requires std:: totally_ordered < W > ;
    		(4) (seit C++20)
    friend constexpr bool operator >=

    ( const /*iterator*/ & x, const /*iterator*/ & y )

    requires std:: totally_ordered < W > ;
    		(5) (seit C++20)
    friend constexpr bool operator <=>

    ( const /*iterator*/ & x, const /*iterator*/ & y )

    requires std:: totally_ordered < W > && std:: three_way_comparable < W > ;
    		(6) (seit C++20)
    1) Gibt zurück x. value_ == y. value_ .
    2) Gibt x. value_ < y. value_ zurück.
    3) Gibt y < x zurück.
    4) Gibt ! ( y < x ) zurück.
    5) Gibt ! ( x < y ) zurück.
    6) Gibt x. value_ <=> y. value_ zurück.

    Der != -Operator wird synthetisiert aus operator== .

    Diese Funktionen sind für gewöhnliches unqualified oder qualified lookup nicht sichtbar und können nur durch argument-dependent lookup gefunden werden, wenn iterator eine assoziierte Klasse der Argumente ist.

    operator+ (std::ranges::iota_view:: iterator )

    friend constexpr /*iterator*/ operator +

    ( /*iterator*/ i, difference_type n )

    requires /*advanceable*/ < W > ;
    		(1) (since C++20)
    friend constexpr /*iterator*/ operator +

    ( difference_type n, /*iterator*/ i )

    requires /*advanceable*/ < W > ;
    		(2) (since C++20)

    Entspricht i + = n ; return i ; .

    Diese Funktionen sind für gewöhnliches unqualified oder qualified lookup nicht sichtbar und können nur durch argument-dependent lookup gefunden werden, wenn iterator eine assoziierte Klasse der Argumente ist.

    operator- (std::ranges::iota_view:: iterator )

    friend constexpr /*iterator*/ operator -

    ( /*iterator*/ i, difference_type n )

    requires /*advanceable*/ < W > ;
    		(1) (seit C++20)
    friend constexpr difference_type operator -

    ( const /*iterator*/ & x, const /*iterator*/ & y )

    requires /*advanceable*/ < W > ;
    		(2) (seit C++20)
    1) Entspricht i - = n ; return i ; .
    2) Sei D difference_type :

    Diese Funktionen sind für gewöhnliche unqualifizierte oder qualifizierte Suche nicht sichtbar und können nur durch argumentabhängige Suche gefunden werden, wenn iterator eine assoziierte Klasse der Argumente ist.

    Fehlerberichte

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

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    P2259R1 C++20 member iterator_category ist immer definiert nur definiert wenn W incrementable erfüllt
    LWG 3580 C++20 Implementierungen von operator + und operator - schließen implizites Move aus für implizites Move angepasst