Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::iota_view
Member functions
Deduction guides
Nested classes
Iterator
Helper concepts
Member types
Member functions
Non-member functions
Sentinel
Member functions
Non-member functions
**Übersetzungshinweise:** - `concept` wurde zu `Konzept` übersetzt (C++20 Konzepte-Terminologie) - `requires` wurde zu `erfordert` übersetzt - `exposition only` wurde zu `Nur zur Veranschaulichung` übersetzt - Alle HTML-Tags, Attribute und C++-spezifischen Begriffe (wie `template`, `class`, `std::incrementable`, `std::same_as`, Operatoren) wurden beibehalten - Die ursprüngliche Formatierung und Struktur wurde vollständig erhalten (Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags und Attribute gemäß den Anweisungen unverändert bleiben sollen und die Tabellenzellen leer sind.)
struct /*iterator*/ ;
(1) ( exposition only* )
Hilfs-Alias-Templates
template < class I >
using /*iota-diff-t*/ = /* siehe unten */ ;
(2) ( Nur zur Darstellung* )
Hilfskonzepte
template < class I >

Konzept /*decrementable*/ =
std:: incrementable < I > && erfordert ( 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) ( exposition only* )
1) ranges:: iota_view < W, Bound > :: iterator ist der Typ der Iteratoren, die von begin() und end() von ranges:: iota_view < W, Bound > zurückgegeben werden.
2) Berechnet den Differenztyp für beide Iteratortypen und integer-like types .
  • Wenn I kein integraler Typ ist, oder wenn es ein integraler Typ ist und sizeof ( std:: iter_difference_t < I > ) größer ist als sizeof ( I ) , dann ist /*iota-diff-t*/ < I > gleich std:: iter_difference_t < I > .
  • Andernfalls ist /*iota-diff-t*/ < I > ein vorzeichenbehafteter Ganzzahltyp mit größerer Breite als I , falls ein solcher Typ existiert.
  • Andernfalls ist I einer der breitesten integralen Typen, und /*iota-diff-t*/ < I > ist ein nicht spezifizierter signed-integer-like type mit einer Breite nicht kleiner als die Breite von I . In diesem Fall ist nicht spezifiziert, ob /*iota-diff-t*/ < I > das Konzept weakly_incrementable modelliert.
3) Spezifiziert, dass ein Typ incrementable ist, und Prä- und Post- operator -- für den Typ die übliche Bedeutung haben.
4) Spezifiziert, 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*/ Modelle

Es erfüllt jedoch nur LegacyInputIterator , wenn W das Konzept incrementable modelliert, und erfüllt LegacyInputIterator andernfalls nicht.

Inhaltsverzeichnis

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:

Datenmitglieder

Mitglied Definition
W value_ der aktuelle Wert
( Nur-Darstellungs-Mitgliedsobjekt* )

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