Namespaces
Variants

std::ranges:: views:: slide, std::ranges:: slide_view

From cppreference.net
Ranges library
Range adaptors
Definido en el encabezado <ranges>
template < ranges:: forward_range V >

requires ranges:: view < V >
class slide_view

: public ranges:: view_interface < slide_view < V >>
(1) (desde C++23)
namespace views {

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

}
(2) (desde C++23)
Firma de llamada
template < ranges:: viewable_range R >
constexpr ranges:: view auto slide ( R && r, ranges:: range_difference_t < R > n ) ;
(desde C++23)
template < class DifferenceType >
constexpr /* objeto adaptador de rango */ slide ( DifferenceType && n ) ;
(desde C++23)
Conceptos auxiliares
template < class V >

concept /*slide-caches-nothing*/ =

ranges:: random_access_range < V > && ranges:: sized_range < V > ;
(3) ( solo exposición* )
template < class V >

concept /*slide-caches-last*/ =
! /*slide-caches-nothing*/ < V > &&

ranges:: bidirectional_range < V > && ranges:: common_range < V > ;
(4) ( solo exposición* )
template < class V >

concept /*slide-caches-first*/ =

! /*slide-caches-nothing*/ < V > && ! /*slide-caches-last*/ < V > ;
(5) ( solo exposición* )
1) slide_view es un adaptador de rango que toma una view y un número n y produce una vista cuyo m th elemento (una "ventana") es una vista sobre [ m , m + n - 1 ] elementos de la vista original.
Sea s el tamaño de la vista original. Entonces el tamaño de la vista producida es:
  • s - n + 1 , si s >= n ,
  • 0 en caso contrario, y la vista resultante está vacía.
2) El nombre views :: slide denota un RangeAdaptorObject . Dadas las subexpresiones e y n , la expresión views :: slide ( e, n ) es equivalente-expresión a slide_view ( e, n ) .

Si n no es mayor que 0 , el comportamiento es indefinido.

slide_view siempre modela forward_range , y modela bidirectional_range , random_access_range , o sized_range si la vista adaptada view modela el concepto correspondiente.

Contenidos

Miembros de datos

Miembro Descripción
V base_ la vista subyacente
( objeto miembro solo para exposición* )
ranges:: range_difference_t < V > n_ el tamaño de "ventana"
( objeto miembro solo para exposición* )
non-propagating-cache < ranges:: iterator_t < V >> cached_begin_
(presente solo si V modela slide-caches-first )
un objeto que almacena en caché el resultado de begin()
( objeto miembro solo para exposición* )
non-propagating-cache < ranges:: iterator_t < V >> cached_end_
(presente solo si V modela slide-caches-last )
un objeto que almacena en caché el resultado de end()
( objeto miembro solo para exposición* )

Funciones miembro

construye un slide_view
(función miembro pública)
devuelve un iterador al inicio
(función miembro pública)
devuelve un iterador o un centinela al final
(función miembro pública)
devuelve el número de elementos, proporcionado solo si el rango subyacente (adaptado) satisface sized_range
(función miembro pública)
devuelve el tamaño aproximado del approximately_sized_range resultante
(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 elemento n ésimo en la vista derivada, proporcionado solo si satisface random_access_range
(función miembro pública de std::ranges::view_interface<D> )

Guías de deducción

Clases anidadas

(C++23)
el tipo de iterador
( clase plantilla miembro solo para exposición* )
(C++23)
el tipo centinela utilizado cuando slide_view no es un common_range
( clase plantilla miembro solo para exposición* )

Plantillas auxiliares

template < class V >

constexpr bool ranges:: enable_borrowed_range < slide_view < V >> =

ranges:: enable_borrowed_range < V > ;
(desde C++23)

Esta especialización de ranges::enable_borrowed_range hace que slide_view satisfaga borrowed_range cuando la vista subyacente la satisface.

Notas

Existen similitudes entre ranges::adjacent_view y ranges::slide_view :

  • Ambos crean una "ventana deslizante" de tamaño N .
  • Ambos tienen el mismo tamaño S - N + 1 , donde S es el tamaño de una view adaptada tal que S >= N > 0 .

La siguiente tabla muestra las diferencias entre estos adaptadores:

Adaptador de vista value_type El tamaño de ventana N
ranges:: adjacent_view std::tuple Un parámetro de plantilla
ranges :: slide_view ranges:: range Un argumento en tiempo de ejecución
Macro de prueba de características Valor Estándar Característica
__cpp_lib_ranges_slide 202202L (C++23) std::ranges::slide_view

Ejemplo

#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <ranges>
auto print_subrange = [](std::ranges::viewable_range auto&& r)
{
    std::cout << '[';
    for (char space[]{0,0}; auto elem : r)
        std::cout << space << elem, *space = ' ';
    std::cout << "] ";
};
int main()
{
    const auto v = {1, 2, 3, 4, 5, 6};
    std::cout << "All sliding windows of width:\n";
    for (const unsigned width : std::views::iota(1U, 1U + v.size()))
    {
        auto const windows = v | std::views::slide(width);
        std::cout << "W = " << width << ": ";
        std::ranges::for_each(windows, print_subrange);
        std::cout << '\n';
    }
}

Salida:

All sliding windows of width W:
W = 1: [1] [2] [3] [4] [5] [6] 
W = 2: [1 2] [2 3] [3 4] [4 5] [5 6] 
W = 3: [1 2 3] [2 3 4] [3 4 5] [4 5 6] 
W = 4: [1 2 3 4] [2 3 4 5] [3 4 5 6] 
W = 5: [1 2 3 4 5] [2 3 4 5 6] 
W = 6: [1 2 3 4 5 6]

Referencias

  • Estándar C++23 (ISO/IEC 14882:2024):
  • 26.7.29 Vista deslizante [range.slide]

Véase también

una view que consiste en tuplas de referencias a elementos adyacentes de la vista adaptada
(plantilla de clase) (objeto adaptador de rango)
un rango de view s que son fragmentos sucesivos no superpuestos de tamaño N de los elementos de otra view
(plantilla de clase) (objeto adaptador de rango)