Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::repeat_view
Definido en el encabezado <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) (desde C++23)
namespace views {

inline constexpr /* no especificado */ repeat = /* no especificado */ ;

}
(2) (desde C++23)
Firma de llamada
template < class W >

requires /* ver más abajo */

constexpr /* ver más abajo */ repeat ( W && value ) ;
(desde C++23)
template < class W, class Bound >

requires /* ver más abajo */

constexpr /* ver más abajo */ repeat ( W && value, Bound && bound ) ;
(desde C++23)
Conceptos auxiliares
concept /*integer-like-with-usable-difference-type*/ =

/*is-signed-integer-like*/ < T > ||

( /*is-integer-like*/ < T > && std:: weakly_incrementable < T > )
(3) ( solo para exposición* )
1) Una fábrica de rangos que genera una secuencia de elementos produciendo repetidamente el mismo valor. Puede ser acotada o no acotada (infinita).
2) views :: repeat ( e ) y views :: repeat ( e, f ) son equivalentes-expresión a repeat_view < std:: decay_t < decltype ( ( E ) ) >> ( e ) y repeat_view ( e, f ) respectivamente para cualesquiera subexpresiones adecuadas e y f .
3) Determina si un tipo es integer-like y tiene un difference type utilizable.

repeat_view modela random_access_range . Si Bound no es std::unreachable_sentinel_t , repeat_view también modela sized_range y common_range .

Contenidos

Objetos de punto de personalización

El nombre views::repeat denota un objeto de punto de personalización , que es un objeto función constante de tipo clase literal semiregular . Consulte CustomizationPointObject para más detalles.

Miembros de datos

Miembro Definición
movable-box  < W > value_ el elemento repetitivo de la vista
( objeto miembro solo para exposición* )
Bound bound_ el valor centinela
( objeto miembro solo para exposición* )

Funciones miembro

crea un repeat_view
(función miembro pública)
obtiene el iterador inicial de un repeat_view
(función miembro pública)
obtiene el centinela que denota el final de un repeat_view
(función miembro pública)
obtiene el tamaño de un repeat_view si tiene tamaño definido
(función miembro pública)
Heredado de std::ranges::view_interface
devuelve si la vista derivada está vacía, proporcionado solo si satisface sized_range o forward_range
(función miembro pública de std::ranges::view_interface<D> )
(C++23)
devuelve un iterador constante al inicio del rango
(función miembro pública de std::ranges::view_interface<D> )
(C++23)
devuelve un centinela para el iterador constante del rango
(función miembro pública de std::ranges::view_interface<D> )
devuelve si la vista derivada no está vacía, proporcionado solo si ranges::empty es aplicable a ella
(función miembro pública de std::ranges::view_interface<D> )
devuelve el primer elemento en la vista derivada, proporcionado si satisface forward_range
(función miembro pública de std::ranges::view_interface<D> )
devuelve el último elemento en la vista derivada, proporcionado solo si satisface bidirectional_range y common_range
(función miembro pública de std::ranges::view_interface<D> )
devuelve el n ésimo elemento en la vista derivada, proporcionado solo si satisface random_access_range
(función miembro pública de std::ranges::view_interface<D> )

std::ranges::repeat_view:: repeat_view

repeat_view ( ) requires std:: default_initializable < W > = default ;
(1) (desde C++23)
constexpr explicit repeat_view ( const W & value, Bound bound = Bound ( ) ) ;
(2) (desde C++23)
constexpr explicit repeat_view ( W && value, Bound bound = Bound ( ) ) ;
(3) (desde 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) (desde C++23)
1) Inicializa por defecto value_ e inicializa por valor bound_ .
2) Inicializa value_ con value e inicializa bound_ con bound .
Si Bound no es std::unreachable_sentinel_t y bool ( bound >= 0 ) es false , el comportamiento es indefinido.
3) Inicializa value_ con std :: move ( value ) e inicializa bound_ con bound .
Si Bound no es std::unreachable_sentinel_t y bool ( bound >= 0 ) es false , el comportamiento es indefinido.
4) Inicializa value_ con std:: make_from_tuple < T > ( std :: move ( value_args ) ) y bound_ con std:: make_from_tuple < Bound > ( std :: move ( bound_args ) ) .
Si Bound no es std::unreachable_sentinel_t y bool ( bound >= 0 ) es false , el comportamiento es indefinido.

Parámetros

value - el valor a producir repetidamente
bound - el límite
value_args - la tupla que contiene los inicializadores de value_
bound_args - la tupla que contiene los inicializadores de bound_

std::ranges::repeat_view:: begin

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

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

std::ranges::repeat_view:: end

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

std::ranges::repeat_view:: size

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

Devuelve to-unsigned-like  ( bound_  ) .

Guías de deducción

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

Clases anidadas

el tipo de iterador
( clase miembro solo para exposición* )

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_ranges_repeat 202207L (C++23) std::ranges::repeat_view

Ejemplo

Ejecutar este código 
#include <iostream>
#include <ranges>
#include <string_view>
using namespace std::literals;
int main()
{
    // sobrecarga acotada
    for (auto s : std::views::repeat("C++"sv, 3))
        std::cout << s << ' ';
    std::cout << '\n';
    // sobrecarga no acotada
    for (auto s : std::views::repeat("I know that you know that"sv)
                | std::views::take(3))
        std::cout << s << ' ';
    std::cout << "...\n";
}

Salida: 

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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 4053 C++20 las llamadas unarias a views::repeat no decaían el argumento decaer el argumento
LWG 4054 C++20 llamar a views::repeat con un repeat_view
no creaba un repeat_view anidado 		crea un
repeat_view anidado

Véase también

(C++20)
una view que consiste en una secuencia generada incrementando repetidamente un valor inicial
(plantilla de clase) (objeto de punto de personalización)