Namespaces
Variants

    std::ranges::views::iota, std::ranges::iota_view, std::ranges::views::indices

    Von de.cppreference.net
     
    C++
     
    Bereichsbibliothek
    Bereichsadaptoren
     
    std::ranges::iota_view
    Mitgliedsfunktionen
    Ableitungsleitfäden
    Verschachtelte Klassen
    Iterator
    Hilfskonzepte
    Mitgliedstypen
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
    Sentinel
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
     
    Definiert in Header <ranges> 
    template< std::weakly_incrementable W,
          std::semiregular Bound = std::unreachable_sentinel_t >
    requires /*weakly-equality-comparable-with*/<W, Bound> && std::copyable<W>
class iota_view
    : public ranges::view_interface<iota_view<W, Bound>>
    		(1) (seit C++20) 
    namespace views {
    inline constexpr /* unspecified */ iota = /* unspecified */;
}
    		(2) (seit C++20) 
    namespace views {
    inline constexpr /* unspecified */ indices = /* unspecified */;
}
    		(3) (seit C++26)
    Aufrufsignatur
    		 
    template< class W >
    requires /* see below */
constexpr /* see below */ iota( W&& value );
    		(seit C++20) 
    template< class W, class Bound >
    requires /* see below */
constexpr /* see below */ iota( W&& value, Bound&& bound );
    		(seit C++20) 
    template< class T >
    requires /*is-integer-like*/<T>
constexpr /* see below */ indices( T bound );
    		(seit C++26)
    1) Eine Bereichsfabrik, die eine Folge von Elementen erzeugt, indem sie einen Anfangswert wiederholt inkrementiert. Sie kann entweder begrenzt oder unbegrenzt (unendlich) sein.
    2) views::iota(e) und views::iota(e, f) sind ausdrucksäquivalent zu iota_view<std::decay_t<decltype((e))>>(e) bzw. iota_view(e, f) für beliebige geeignete Teilausdrücke e und f.
    3) Sei T gleich std::remove_cvref_t<decltype((e))>. Dann ist views::indices(e) ausdrucksäquivalent zu views::iota(T(0), e) für jeden geeigneten Teilausdruck e, falls /*is-integer-like*/<T> true ist.

    Customization Point Objects

    Der Name views::iota bezeichnet ein Customization Point Object , welches ein konstantes Function Object eines Literal semiregular -Klassentyps ist. Weitere Details finden Sie unter CustomizationPointObject .

    Datenelemente

    Element Beschreibung
    W value_ der Anfangswert
    (nur zur Veranschaulichung dienendes Mitgliedsobjekt*)
    Bound bound_ der Sentinelwert, kann unerreichbar sein
    (nur zur Veranschaulichung dienendes Mitgliedsobjekt*)

    Memberfunktionen

    		erstellt einen iota_view
    (öffentliche Elementfunktion)
    		liefert den Beginn-Iterator eines iota_view
    (öffentliche Elementfunktion)
    		liefert den Sentinel, der das Ende eines iota_view markiert
    (öffentliche Elementfunktion)
    		prüft, ob der iota_view leer ist (d.h. Iterator und Sentinel gleich sind)
    (öffentliche Elementfunktion)
    (optional)
    		liefert die Größe eines iota_view (nur bereitgestellt, wenn er begrenzt ist)
    (öffentliche Elementfunktion)
    Geerbt von ranges::view_interface
    (C++23)
    		 gibt einen konstanten Iterator zum Anfang des Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen Sentinel für den konstanten Iterator des Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt zurück, ob die abgeleitete Ansicht nicht leer ist, jedoch nur, wenn ranges::empty darauf anwendbar ist
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das erste Element in der abgeleiteten Ansicht zurück, sofern es forward_range
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das letzte Element in der abgeleiteten Ansicht zurück, jedoch nur, wenn es bidirectional_range und common_range
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das nte Element in der abgeleiteten Ansicht zurück, jedoch nur, wenn es random_access_range
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)

    Ableitungsleitfäden

    Geschachtelte Klassen

    		der Iteratortyp
    ( Nur zur Darstellung verwendete Memberklasse* )
    		der Sentinel-Typ, der verwendet wird, wenn die iota_view begrenzt ist und Bound und W nicht denselben Typ haben
    ( Nur zur Darstellung verwendete Memberklasse* )

    Hilfsvorlagen

    template < std:: weakly_incrementable W, std:: semiregular Bound >
    constexpr bool ranges:: enable_borrowed_range < ranges :: iota_view < W, Bound >> = true ;
    		(seit C++20)

    Diese Spezialisierung von ranges:: enable_borrowed_range bewirkt, dass iota_view die Anforderungen von borrowed_range erfüllt.

    Mögliche Implementierung

    Siehe auch die Implementierung in libstdc++.

    views::indices (3) 
    namespace views {
    inline constexpr auto indices = []</*is-integer-like*/ I>(I n)
    {
        return views::iota(I{}, n);
    };
}

    Hinweise

    Feature-Test Makro Wert Std Feature
    __cpp_lib_ranges_indices 202506L (C++26) ranges::views::indices

    Beispiel

    Diesen Code ausführen
    #include <algorithm>
#include <iostream>
#include <ranges>
    
struct Bound
{
    int bound;
    bool operator==(int x) const { return x == bound; }
};

int main()
{
    for (int i : std::ranges::iota_view{1, 10})
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (int i : std::views::iota(1, 10))
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (int i : std::views::iota(1, Bound{10}))
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (int i : std::views::iota(1) | std::views::take(9))
        std::cout << i << ' ';
    std::cout << '\n';
    
    std::ranges::for_each(std::views::iota(1, 10),
                          [](int i){ std::cout << i << ' '; });
    std::cout << '\n';

#if __cpp_lib_ranges_indices
    constexpr int v[]{1, 2, 3, 4, 5, 6, 7, 8, 9};

    // auto broken_indices = views::iota(0, std::ranges::size(v));
    //     does not compile due to types (int VS size_t) mismatch

    auto good_indices = std::views::indices(std::ranges::size(v));

    for (auto i : good_indices)
        std::cout << v[i] << ' ';
    std::cout << '\n';
#endif
}

    Ausgabe: 

    1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9

    Fehlerberichte

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

    DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
    LWG 4096 C++20 views::iota konnte eine iota_view unverändert kopieren verboten
    P2325R3 C++20 iota_view erforderte, dass W semiregular ist
    da view default_initializable erforderte     		erfordert nur, dass W copyable ist

    Referenzen

    • C++26-Standard (ISO/IEC 14882:2026):
    • 25.6.4 Iota view [range.iota]
    • C++23-Standard (ISO/IEC 14882:2024):
    • 26.6.4 Iota view [range.iota]
    • C++20-Standard (ISO/IEC 14882:2020):
    • 24.6.4 Iota view [range.iota]

    Siehe auch

    (C++11)
    		 füllt einen Bereich mit aufeinanderfolgenden Inkrementen des Startwerts
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++23)
    (C++23)
    		 füllt einen Bereich mit aufeinanderfolgenden Inkrementen des Startwerts
    (Algorithmus-Funktionsobjekt)
    (C++23)
    		 eine View bestehend aus einer erzeugten Sequenz durch wiederholtes Produzieren desselben Werts
    (Klassenschablone) (Customization-Point-Objekt)
    (C++23)
    		 eine View die jedes Element der angepassten Sequenz auf ein Tupel aus sowohl der Position des Elements als auch seinem Wert abbildet
    (Klassenschablone) (Bereichs-Adapter-Objekt)