Namespaces
Variants

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

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
Definiert im 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)
Aufrufsignatur
template < class W >

requires /* siehe unten */

constexpr /* siehe unten */ iota ( W && value ) ;
(seit C++20)
template < class W, class Bound >

requires /* siehe unten */

constexpr /* siehe unten */ iota ( W && value, Bound && bound ) ;
(seit C++20)
1) Eine Bereichsfabrik, die eine Sequenz von Elementen durch wiederholtes Inkrementieren eines Anfangswerts erzeugt. 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 ) und iota_view ( e, f ) jeweils für beliebige geeignete Teilausdrücke e und f .

Inhaltsverzeichnis

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 .

Datenmitglieder

Mitglied Definition
W value_ der Anfangswert
( Nur zur Veranschaulichung verwendetes Mitgliedsobjekt* )
Bound bound_ der Sentinel-Wert, kann unerreichbar sein
( Nur zur Veranschaulichung verwendetes 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 std::ranges::view_interface
(C++23)
liefert einen konstanten Iterator zum Beginn des Bereichs
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
(C++23)
liefert einen Sentinel für den konstanten Iterator des Bereichs
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt zurück, ob die abgeleitete Ansicht nicht leer ist, bereitgestellt nur wenn ranges::empty darauf anwendbar ist
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
liefert das erste Element in der abgeleiteten Ansicht, bereitgestellt wenn sie forward_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
liefert das letzte Element in der abgeleiteten Ansicht, bereitgestellt nur wenn sie bidirectional_range und common_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
liefert das n -te Element in der abgeleiteten Ansicht, bereitgestellt nur wenn sie 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.

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';
}

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

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

Siehe auch

(C++11)
füllt einen Bereich mit aufeinanderfolgenden Inkrementen des Startwerts
(Funktions-Template)
(C++23)
füllt einen Bereich mit aufeinanderfolgenden Inkrementen des Startwerts
(Algorithmus-Funktionsobjekt)
(C++23)
eine view bestehend aus einer generierten Sequenz durch wiederholtes Erzeugen desselben Werts
(Klassen-Template) (Customization Point Object)
(C++23)
eine view die jedes Element der adaptierten Sequenz auf ein Tupel aus der Position des Elements und seinem Wert abbildet
(Klassen-Template) (Range Adaptor Object)