Namespaces
Variants

std::ranges:: views:: adjacent, std::ranges:: adjacent_view, std::ranges:: views:: pairwise

From cppreference.net
C++
Ranges library
Range adaptors
adjacent_view views::adjacent
(C++23) (C++23)
views::pairwise
(C++23)
(C++23) (C++23)
(C++23)
(C++23) (C++23)
(C++23) (C++23)
(C++23) (C++23)
(C++23) (C++23)
(C++23) (C++23)

std::ranges::adjacent_view
Member functions
(C++26)
Iterator
Member functions
Non-member functions
Sentinel
Member functions
Non-member functions
Definido en el encabezado <ranges>
template < ranges:: forward_range V, std:: size_t N >

requires ranges:: view < V > && ( N > 0 )
class adjacent_view

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

template < std:: size_t N >
constexpr /* no especificado */ adjacent = /* no especificado */ ;

}
(2) (desde C++23)
namespace views {

inline constexpr auto pairwise = adjacent < 2 > ;

}
(3) (desde C++23)
Firma de llamada
template < ranges:: viewable_range R >

requires /* ver más abajo */

constexpr ranges:: view auto adjacent < N > ( R && r ) ;
(desde C++23)
1) adjacent_view es un adaptador de rango que toma una view y produce una view cuyo i th elemento (una "ventana") es un std::tuple que contiene N referencias a los elementos [ i , i + N - 1 ] 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 :: adjacent < N > denota un RangeAdaptorObject . Dada una subexpresión e y una expresión constante N , la expresión views :: adjacent < N > ( e ) es equivalente-expresión a
3) El nombre views :: pairwise denota un RangeAdaptorObject que se comporta exactamente como views :: adjacent < 2 > .

adjacent_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 view subyacente
( miembro objeto solo para exposición* )

Funciones miembro

construye un adjacent_view
(función miembro pública)
devuelve un iterador al inicio
(función miembro pública)
devuelve un iterador o 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)
(C++26)
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

(ninguno)

Clases anidadas

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

Plantillas auxiliares

template < class V, size_t N >

constexpr bool ranges:: enable_borrowed_range < adjacent_view < V, N >> =

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

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

Notas

views :: adjacent solo acepta rangos forward incluso cuando N es 0 .

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 Std Característica
__cpp_lib_ranges_zip 202110L (C++23) ranges:: zip_view ,
ranges:: zip_transform_view ,
ranges::adjacent_view ,
ranges:: adjacent_transform_view

Ejemplo

Ejecutar este código 
#include <array>
#include <format>
#include <iostream>
#include <ranges>
#include <tuple>
int main()
{
    constexpr std::array v{1, 2, 3, 4, 5, 6};
    std::cout << "v = [1 2 3 4 5 6]\n";
    for (int i{}; std::tuple t : v | std::views::adjacent<3>)
    {
        auto [t0, t1, t2] = t;
        std::cout << std::format("e = {:<{}}[{} {} {}]\n", "", 2 * i++, t0, t1, t2);
    }
}

Salida: 

v = [1 2 3 4 5 6]
e = [1 2 3]
e =   [2 3 4]
e =     [3 4 5]
e =       [4 5 6]

Informes de defectos

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

DR Se aplica a Comportamiento publicado Comportamiento correcto
LWG 4098 C++23 views :: adjacent < 0 > aceptaba rangos de solo entrada se rechaza

Referencias

  • Estándar C++23 (ISO/IEC 14882:2024):
  • 26.7.25 Vista adyacente [range.adjacent]

Véase también

(C++23)
una view que consiste en los resultados de la aplicación de una función de transformación a elementos adyacentes de la vista adaptada
(plantilla de clase) (objeto adaptador de rango)
(C++23)
una view cuyo M-ésimo elemento es una view sobre los elementos M-ésimo hasta (M + N - 1)-ésimo de otra view
(plantilla de clase) (objeto adaptador de rango)
(C++23)
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)
(C++23)
una view que consiste en elementos de otra view , avanzando N elementos a la vez
(plantilla de clase) (objeto adaptador de rango)