Namensräume
Varianten
Aktionen

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

Von cppreference.com
< cpp‎ | ranges‎ | iota view
 
C++
 
Bereichsbibliothek
Range-Adaptoren
 
std::ranges::iota_view
Memberfunktionen
Deduction Guides
Verschachtelte Klassen
Iterator
Hilfskonzepte
Membertypen
Memberfunktionen
Nicht-Member-Funktionen
Sentinel
Memberfunktionen
Nicht-Member-Funktionen
 
struct /*iterator*/;
 (1) (nur Exposition*)
Hilfs-Alias-Templates
template< class I >
using /*iota-diff-t*/ = /* siehe unten */;
 (2) (nur Exposition*)
Hilfskonzepte
template< class I >

concept /*decrementable*/ =
    std::incrementable<I> && requires(I i) {
        { --i } -> std::same_as<I&>;
        { i-- } -> std::same_as<I>;

    };
 (3) (nur Exposition*)
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 Exposition*)
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-ähnliche Typen.
  • Wenn I kein integraler Typ ist, oder wenn 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 Ganzzahltyp, dessen Breite größer ist 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 nicht spezifizierter vorzeichenbehafteter Ganzzahl-ähnlicher Typ mit einer Breite, die nicht kleiner ist als die Breite von I. Es ist nicht spezifiziert, ob /*iota-diff-t*/<I> in diesem Fall weakly_incrementable modelliert.
3) Gibt an, dass ein Typ incrementable ist und dass die Prä- und Postfix- operator-- für den Typ eine übliche 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 Differenztyp eine übliche Bedeutung haben.

/*iterator*/ modelliert

Es erfüllt jedoch nur LegacyInputIterator, wenn W incrementable modelliert, und erfüllt andernfalls kein LegacyInputIterator.

Inhalt

[edit] Semantische Anforderungen

3) Typ I modelliert decrementable nur, wenn I decrementable und alle von ihm umfassten Konzepte erfüllt, und bei gleichen Objekten a und b vom Typ I
  • Wenn a und b im Definitionsbereich von Prä- und Postfix- operator-- liegen (d. h. sie sind dekremetierbar), dann sind alle folgenden Ausdrücke true
  • Wenn a und b im Definitionsbereich von Prä- und Postfix- operator++ liegen (d. h. sie sind inkremetierbar), dann ist bool(--(++a) = = b) true.
4) Sei D /*iota-diff-t*/<I>. Typ I modelliert advanceable nur, wenn I advanceable und alle von ihm umfassten Konzepte erfüllt, und bei
  • Objekten 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) gleich b ist.
  • std::addressof(a += n) ist gleich std::addressof(a).
  • I(a + n) ist gleich (a += n).
  • Für alle zwei positiven Werte x und y vom Typ D, wenn I(a + D(x + y)) wohlgeformt ist, dann ist I(a + D(x + y)) gleich I(I(a + x) + y).
  • I(a + D(0)) ist gleich a.
  • Wenn I+ D(0)) wohlgeformt ist, dann ist I(a + D(n - 1)) gleich [](I c) { return ++c; }(I+ D(n - 1))).
  • (b += -n) ist gleich a.
  • (b -= n) ist gleich 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.

[edit] Verschachtelte Typen

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

[edit] Ermittlung des Iterator-Konzepts

iterator_concept ist wie folgt definiert

[edit] Datenmember

Mitglied Definition
W value_ der aktuelle Wert
((exposition-only member object*)

[edit] Member-Funktionen

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) Initialisiert value_ mit Wertinitialisierung.
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

Führen Sie diesen Code aus
#include <cassert>
#include <ranges>
 
int main()
{
    auto it{std::views::iota(6, 9).begin()};
    const int& r = *it; // binds with temporary
    assert(*it == 6 and r == 6);
    ++it;
    assert(*it == 7 and r == 6);
}

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) Äquivalent zu ++value_ ; return *this;.
2) Äquivalent zu ++value_ ;.
3) Äquivalent zu auto tmp = *this; ++value_ ; return tmp;.

Beispiel

Führen Sie diesen Code aus
#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) Äquivalent zu --value_ ; return *this;.
2) Äquivalent zu auto tmp = *this; --value_ ; return tmp;.

Beispiel

Führen Sie diesen Code aus
#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

Führen Sie diesen Code aus
#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

Führen Sie diesen Code aus
#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

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

[edit] 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 x.value_ = = y.value_ zurück.
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 aus operator== synthetisiert.

Diese Funktionen sind für die nicht-qualifizierte oder qualifizierte Suche nicht sichtbar und können nur durch Argument-abhängige Suche gefunden werden, wenn iterator eine zugeordnete 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 /*iterator*/ operator+

    ( difference_type n, /*iterator*/ i )

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

Äquivalent zu i += n; return i;.

Diese Funktionen sind für die nicht-qualifizierte oder qualifizierte Suche nicht sichtbar und können nur durch Argument-abhängige Suche gefunden werden, wenn iterator eine zugeordnete 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) Äquivalent zu i -= n; return i;.
2) Sei D difference_type

Diese Funktionen sind für die nicht-qualifizierte oder qualifizierte Suche nicht sichtbar und können nur durch Argument-abhängige Suche gefunden werden, wenn iterator eine zugeordnete Klasse der Argumente ist.

[edit] Defect Reports

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

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
P2259R1 C++20 Member iterator_category ist immer definiert Nur definiert, wenn W incrementable erfüllt
LWG 3580 C++20 Körper von operator+ und operator- schließen implizites Verschieben aus für implizites Verschieben geeignet gemacht
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/ranges/iota_view/iterator&oldid=176931"