Namespaces
Variants

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

De es.cppreference.net
 
 
Biblioteca de rangos
Adaptadores de rango
 
 
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 /* unspecified */ repeat = /* unspecified */;
}
(2) (desde C++23)
Firma de llamada
template< class W >
    requires /* see below */
constexpr /* see below */ repeat( W&& value );
(desde C++23)
template< class W, class Bound >
    requires /* see below */
constexpr /* see below */ 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 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 en expresión a repeat_view<std::decay_t<decltype((E))>>(e) y repeat_view(e, f) respectivamente para cualquier subexpresión adecuada e y f.
3) Determina si un tipo es similar a entero y tiene un tipo de diferencia 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.

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 ranges::view_interface
devuelve si la vista derivada está vacía, 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, solo si ranges::empty se le puede aplicar
(función miembro pública de std::ranges::view_interface<D>)
devuelve el primer elemento en la vista derivada, si satisface forward_range
(función miembro pública de std::ranges::view_interface<D>)
devuelve el último elemento en la vista derivada, 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, 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_  ) .

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

#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

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