Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Bereichsbibliothek
    Bereichsadaptoren
     
    std::ranges::iota_view
    Mitgliedsfunktionen
    Ableitungsregeln
    Verschachtelte Klassen
    Iterator
    Hilfskonzepte
    Mitgliedstypen
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
    Sentinel
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
     
    iota_view() requires std::default_initializable<W> = default;
    		(1) (seit C++20) 
    constexpr explicit iota_view( W value );
    		(2) (seit C++20) 
    constexpr explicit iota_view( std::type_identity_t<W> value,
                              std::type_identity_t<Bound> bound );
    		(3) (seit C++20) 
    constexpr explicit iota_view( /*iterator*/ first, /* see below */ last );
    		(4) (seit C++20)

    Konstruiert eine iota_view.

    1) Standardkonstruktor. Wertinitialisiert die zugrundeliegenden value_ und bound_.
    2) Initialisiert value_ mit value und wertinitialisiert bound_.
    • Das Verhalten ist undefiniert, wenn:
    • Bound nicht std::unreachable_sentinel_t ist und Bound() von value aus nicht erreichbar ist.
    • std::totally_ordered_with<W, Bound> modelliert wird und bool(value <= Bound()) false ist.
    3) Initialisiert value_ mit value und bound_ mit bound.
    • Das Verhalten ist undefiniert, wenn:
    • Bound nicht std::unreachable_sentinel_t ist und bound von value aus nicht erreichbar ist.
    • std::totally_ordered_with<W, Bound> modelliert wird und bool(value <= bound) false ist.
    4) Initialisiert value_ mit dem in W gespeicherten Wert first und initialisiert bound_ mit dem durch Bound dargestellten Wert last (der denselben Typ hat wie der von end()).
    • Falls W und Bound derselbe Typ sind, äquivalent zu iota_view(first.value_, last.value_).
    • Andernfalls, falls Bound std::unreachable_sentinel_t ist, äquivalent zu iota_view(first.value_, last).
    • Andernfalls äquivalent zu iota_view(first.value_, last.bound_).

    Parameter

    value - der Startwert
    bound - die Grenze
    first - der Iterator, der den Startwert bezeichnet
    last - der Iterator oder Sentinel, der die Grenze bezeichnet

    Beispiel

    Diesen Code ausführen 
    #include <cassert>
#include <iostream>
#include <iterator>
#include <ranges>
int main()
{
    const auto l = {1, 2, 3, 4};
    auto i1 = std::ranges::iota_view<int, int>(); // Überladung (1)
    assert(i1.empty() and i1.size() == 0);
    auto i2 = std::ranges::iota_view(1); // Überladung (2)
    assert(not i2.empty() and i2.front() == 1);
    for (std::cout << "1) "; auto e : i2 | std::views::take(3))
        std::cout << e << ' ';
    std::cout << '\n';
    auto i3 = std::ranges::iota_view(std::begin(l)); // Überladung (2)
    assert(not i3.empty() and i3.front() == l.begin());
    for (std::cout << "2) "; auto e : i3 | std::views::take(4))
        std::cout << *e << ' ';
    std::cout << '\n';
    auto i4 = std::ranges::iota_view(1, 8); // Überladung (3)
    assert(not i4.empty() and i4.front() == 1 and i4.back() == 7);
    for (std::cout << "3) "; auto e : i4)
        std::cout << e << ' ';
    std::cout << '\n';
    auto i5 = std::ranges::iota_view(l.begin(), l.end()); // Überladung (4)
    for (std::cout << "4) "; auto e : i5)
        std::cout << *e << ' ';
    std::cout << '\n';
    auto i6 = std::ranges::iota_view(l.begin(), std::unreachable_sentinel); // (4)
    for (std::cout << "5) "; auto e : i6 | std::views::take(3))
        std::cout << *e << ' ';
    std::cout << '\n';
}

    Ausgabe: 

    1) 1 2 3
2) 1 2 3 4
3) 1 2 3 4 5 6 7
4) 1 2 3 4
5) 1 2 3

    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
    LWG 3523 C++20 Überladung (4) könnte falschen Sentinel-Typ verwenden korrigiert
    P2711R1 C++20 Überladungen (3,4) waren nicht explizit explizit gemacht