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
Défini dans l'en-tête <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) (depuis C++20)
namespace views {

inline constexpr /* non spécifié */ iota = /* non spécifié */ ;

}
(2) (depuis C++20)
Signature d'appel
template < class W >

requires /* voir ci-dessous */

constexpr /* voir ci-dessous */ iota ( W && value ) ;
(depuis C++20)
template < class W, class Bound >

requires /* voir ci-dessous */

constexpr /* voir ci-dessous */ iota ( W && value, Bound && bound ) ;
(depuis C++20)
1) Une fabrique de plages qui génère une séquence d'éléments en incrémentant répétitivement une valeur initiale. Peut être bornée ou non bornée (infinie).
2) views :: iota ( e ) et views :: iota ( e, f ) sont équivalents en expression à iota_view < std:: decay_t < decltype ( ( e ) ) >> ( e ) et iota_view ( e, f ) respectivement pour toutes sous-expressions appropriées e et f .

Table des matières

Objets de point de personnalisation

Le nom views::iota désigne un objet de point de personnalisation , qui est un objet fonction constant d'un type de classe littéral semiregular . Voir CustomizationPointObject pour plus de détails.

Membres de données

Membre Définition
W value_ la valeur de début
( objet membre d'exposition uniquement* )
Bound bound_ la valeur sentinelle, peut être inaccessible
( objet membre d'exposition uniquement* )

Fonctions membres

crée un iota_view
(fonction membre publique)
obtient l'itérateur de début d'un iota_view
(fonction membre publique)
obtient le sentinelle dénotant la fin d'un iota_view
(fonction membre publique)
teste si le iota_view est vide (c'est-à-dire si l'itérateur et le sentinelle sont égaux)
(fonction membre publique)
(optional)
obtient la taille d'un iota_view (fournie uniquement s'il est borné)
(fonction membre publique)
Hérité de std::ranges::view_interface
(C++23)
retourne un itérateur constant vers le début de la plage
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un sentinelle pour l'itérateur constant de la plage
(fonction membre publique de std::ranges::view_interface<D> )
retourne si la vue dérivée n'est pas vide, fournie uniquement si ranges::empty lui est applicable
(fonction membre publique de std::ranges::view_interface<D> )
retourne le premier élément de la vue dérivée, fournie si elle satisfait forward_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le dernier élément de la vue dérivée, fournie uniquement si elle satisfait bidirectional_range et common_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le n ième élément de la vue dérivée, fournie uniquement si elle satisfait random_access_range
(fonction membre publique de std::ranges::view_interface<D> )

Guides de déduction

Classes imbriquées

le type d'itérateur
( classe membre d'exposition uniquement* )
le type sentinelle utilisé lorsque le iota_view est borné et que Bound et W ne sont pas du même type
( classe membre d'exposition uniquement* )

Modèles d'assistance

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

Cette spécialisation de ranges:: enable_borrowed_range permet à iota_view de satisfaire borrowed_range .

Exemple

Exécuter ce code 
#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';
}

Sortie : 

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
LWG 4096 C++20 views::iota pouvait copier un iota_view tel quel interdit
P2325R3 C++20 iota_view exigeait que W soit semiregular
car une view exigeait default_initializable 		exige seulement que W soit copyable

Voir aussi

(C++11)
remplit une plage avec des incréments successifs de la valeur de départ
(modèle de fonction)
(C++23)
remplit une plage avec des incréments successifs de la valeur de départ
(objet fonction algorithme)
(C++23)
une view constituée d'une séquence générée en produisant répétitivement la même valeur
(modèle de classe) (objet point de personnalisation)
(C++23)
une view qui mappe chaque élément de la séquence adaptée à un tuple contenant à la fois la position de l'élément et sa valeur
(modèle de classe) (objet adaptateur de plage)