Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
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 /* non spécifié */ repeat = /* non spécifié */ ;

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

requires /* voir ci-dessous */

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

requires /* voir ci-dessous */

constexpr /* voir ci-dessous */ repeat ( W && value, Bound && bound ) ;
(depuis C++23)
Concepts auxiliaires
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 plages qui génère une séquence d'éléments en produisant répétitivement la même valeur. Peut être bornée ou non bornée (infinie).
2) views :: repeat ( e ) et views :: repeat ( e, f ) sont équivalents d'expression à 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 integer-like et possède un difference type utilisable.

repeat_view modélise random_access_range . Si Bound n'est pas std::unreachable_sentinel_t , repeat_view modélise également sized_range et common_range .

Table des matières

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 std::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)
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 sentinel 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> )
retourne 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> )
retourne 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> )
retourne le n è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)