Namespaces
Variants

    std::ranges::views::repeat, std::ranges::repeat_view

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Libre et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support du langage
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de ranges (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et heure
    Bibliothèque d'entrée/sortie
    Bibliothèque de système de fichiers (C++17)
    Bibliothèque de support de la concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque de ranges
    Adaptateurs de range
     
    std::ranges::repeat_view
     
    Défini dans l'en-tête <ranges> 
    template< std::move_constructible W,
          std::semiregular Bound = std::unreachable_sentinel_t >
    requires (std::is_object_v<W> && std::same_as<W, std::remove_cv_t<W>> &&
             (/*integer-like-with-usable-difference-type*/<Bound> ||
              std::same_as<Bound, std::unreachable_sentinel_t>))
class repeat_view : public ranges::view_interface<repeat_view<W, Bound>>
    		(1) (depuis C++23) 
    namespace views {
    inline constexpr /* unspecified */ repeat = /* unspecified */;
}
    		(2) (depuis C++23)
    Signature d'appel
    		 
    template< class W >
    requires /* see below */
constexpr /* see below */ repeat( W&& value );
    		(depuis C++23) 
    template< class W, class Bound >
    requires /* see below */
constexpr /* see below */ repeat( W&& value, Bound&& bound );
    		(depuis C++23)
    Concepts d'aide
    		 
    concept /*integer-like-with-usable-difference-type*/ =
    /*is-signed-integer-like*/<T> ||
    (/*is-integer-like*/ <T> && std::weakly_incrementable<T>)
    		(3) (exposition uniquement*)
    1) Une fabrique de range qui génère une séquence d'éléments en produisant répétitivement la même valeur. Peut être soit bornée soit non bornée (infinie).
    2) views::repeat(e) et views::repeat(e, f) sont équivalents aux expressions à repeat_view<std::decay_t<decltype((E))>>(e) et repeat_view(e, f) respectivement pour toutes sous-expressions appropriées e et f.
    3) Détermine si un type est de type entier et a un type de différence utilisable.

    repeat_view modèle random_access_range. Si Bound n'est pas std::unreachable_sentinel_t, repeat_view modèle aussi sized_range et common_range.

    Objets de point de personnalisation

    Le nom views::repeat 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
    movable-box  < W > value_ l'élément répété de la vue
    ( objet membre d'exposition seulement* )
    Bound bound_ la valeur sentinelle
    ( objet membre d'exposition seulement* )

    Fonctions membres

    		crée un repeat_view
    (fonction membre publique)
    		obtient l'itérateur de début d'un repeat_view
    (fonction membre publique)
    		obtient le sentinel dénotant la fin d'un repeat_view
    (fonction membre publique)
    		obtient la taille d'un repeat_view s'il est dimensionné
    (fonction membre publique)
    Hérité de ranges::view_interface
    		indique si la vue dérivée est vide, fourni uniquement si elle satisfait sized_range ou forward_range
    (fonction membre publique de std::ranges::view_interface<D>)
    (C++23)
    		 renvoie un itérateur constant au début de la plage
    (fonction membre publique de std::ranges::view_interface<D>)
    (C++23)
    		 renvoie un sentinelle pour l'itérateur constant de la plage
    (fonction membre publique de std::ranges::view_interface<D>)
    		indique si la vue dérivée n'est pas vide, fourni uniquement si ranges::empty lui est applicable
    (fonction membre publique de std::ranges::view_interface<D>)
    		renvoie le premier élément de la vue dérivée, fourni si elle satisfait forward_range
    (fonction membre publique de std::ranges::view_interface<D>)
    		renvoie le dernier élément de la vue dérivée, fourni uniquement si elle satisfait bidirectional_range et common_range
    (fonction membre publique de std::ranges::view_interface<D>)
    		renvoie le ni-ème élément de la vue dérivée, fourni uniquement si elle satisfait random_access_range
    (fonction membre publique de std::ranges::view_interface<D>)

    std::ranges::repeat_view:: repeat_view

    repeat_view ( ) requires std:: default_initializable < W > = default ;
    		(1) (depuis C++23)
    constexpr explicit repeat_view ( const W & value, Bound bound = Bound ( ) ) ;
    		(2) (depuis C++23)
    constexpr explicit repeat_view ( W && value, Bound bound = Bound ( ) ) ;
    		(3) (depuis C++23)
    template < class ... WArgs , class ... BoundArgs >

    requires std:: constructible_from < W, WArgs... >
    && std:: constructible_from < Bound, BoundArgs... >
    constexpr explicit
    repeat ( std:: piecewise_construct_t , std:: tuple < WArgs... > value_args,

    std:: tuple < BoundArgs... > bound_args = std:: tuple <> { } ) ;
    		(4) (depuis C++23)
    1) Initialise par défaut value_ et initialise par valeur bound_ .
    2) Initialise value_ avec value et initialise bound_ avec bound .
    Si Bound n'est pas std::unreachable_sentinel_t et bool ( bound >= 0 ) est false , le comportement est indéfini.
    3) Initialise value_ avec std :: move ( value ) et initialise bound_ avec bound .
    Si Bound n'est pas std::unreachable_sentinel_t et bool ( bound >= 0 ) est false , le comportement est indéfini.
    4) Initialise value_ avec std:: make_from_tuple < T > ( std :: move ( value_args ) ) et bound_ avec std:: make_from_tuple < Bound > ( std :: move ( bound_args ) ) .
    Si Bound n'est pas std::unreachable_sentinel_t et bool ( bound >= 0 ) est false , le comportement est indéfini.

    Paramètres

    value - la valeur à produire de manière répétée
    bound - la limite
    value_args - le tuple contenant les initialiseurs de value_
    bound_args - le tuple contenant les initialiseurs de bound_

    std::ranges::repeat_view:: begin

    constexpr /*iterator*/ begin ( ) const ;
    		(depuis C++23)

    Retourne iterator  ( std:: addressof ( * value_  ) ) .

    std::ranges::repeat_view:: end

    constexpr /*iterator*/ end ( ) const
    requires ( ! std:: same_as < Bound, std:: unreachable_sentinel_t > ) ;
    		(1) (depuis C++23)
    constexpr std:: unreachable_sentinel_t end ( ) const ;
    		(2) (depuis C++23)
    1) Retourne iterator  ( std:: addressof ( * value_  ) , bound_  ) .
    2) Retourne std:: unreachable_sentinel .

    std::ranges::repeat_view:: size

    constexpr auto size ( ) const
    requires ( ! std:: same_as < Bound, std:: unreachable_sentinel_t > ) ;
    		(depuis C++23)

    Retourne to-unsigned-like  ( bound_  ) .

    Guides de déduction

    template < class W, class Bound = std:: unreachable_sentinel_t >
    repeat_view ( W, Bound = Bound ( ) ) - > repeat_view < W, Bound > ;
    		(depuis C++23)

    Classes imbriquées

    		le type d'itérateur
    ( classe membre d'exposition uniquement* )

    Notes

    Macro de test de fonctionnalité Valeur Std Fonctionnalité
    __cpp_lib_ranges_repeat 202207L (C++23) std::ranges::repeat_view

    Exemple

    Exécuter ce code 
    #include <iostream>
#include <ranges>
#include <string_view>
using namespace std::literals;
int main()
{
    // surcharge bornée
    for (auto s : std::views::repeat("C++"sv, 3))
        std::cout << s << ' ';
    std::cout << '\n';
    // surcharge non bornée
    for (auto s : std::views::repeat("I know that you know that"sv)
                | std::views::take(3))
        std::cout << s << ' ';
    std::cout << "...\n";
}

    Sortie : 

    C++ C++ C++
I know that you know that I know that you know that I know that you know that ...

    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 4053 C++20 les appels unaires à views::repeat ne dégradaient pas l'argument dégrader l'argument
    LWG 4054 C++20 l'appel de views::repeat avec un repeat_view
    ne créait pas un repeat_view imbriqué     		crée un
    repeat_view imbriqué

    Voir aussi

    (C++20)
    		une view constituée d'une séquence générée en incrémentant répétitivement une valeur initiale
    (modèle de classe) (objet de point de personnalisation)