Namespaces
Variants

std::ranges:: views:: adjacent_transform, std::ranges:: adjacent_transform_view, std::ranges:: views:: pairwise_transform

From cppreference.net
C++
Ranges library
Range adaptors
(C++23) (C++23)
(C++23)
adjacent_transform_view views::adjacent_transform
(C++23) (C++23)
views::pairwise_transform
(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_transform_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:: move_constructible F, std:: size_t N >

requiere ranges:: view < V > && ( N > 0 ) && std:: is_object_v < F > &&
std:: regular_invocable < F & ,
/*REPEAT*/ ( ranges:: range_reference_t < V > , N ) ... > &&
/*can-reference*/ < std:: invoke_result_t < F & ,
/*REPEAT*/ ( ranges:: range_reference_t < V > , N ) ... >>
class adjacent_transform_view

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

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

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

inline constexpr auto pairwise_transform = adjacent_transform < 2 > ;

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

requiere /* ver más abajo */

constexpr ranges:: view auto adjacent_transform < N > ( R && r, F && fun ) ;
(desde C++23)
template < class F >
constexpr /*cierre adaptador de rango*/ adjacent_transform < N > ( F && fun ) ;
(desde C++23)
1) adjacent_transform_view es un adaptador de rango que toma una view y un objeto invocable fun , y produce una view cuyo i ésimo elemento es un valor que resulta de aplicar fun a cada elemento en [ i , i + N ) de la vista original. F siempre tiene aridad N .
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_transform < N > denota un RangeAdaptorObject . Dadas las subexpresiones e y f , y una expresión constante N , la expresión views :: adjacent_transform < N > ( e, f ) es equivalente-expresión a:
3) El nombre views :: pairwise_transform denota un RangeAdaptorObject que se comporta exactamente como views :: adjacent_transform < 2 > . En particular, la aridad de F también es 2 y fun es un objeto invocable binario.

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

Contenidos

Funciones miembro

construye un adjacent_transform_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)
(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 th en la vista derivada, proporcionado solo si satisface random_access_range
(función miembro pública de std::ranges::view_interface<D> )

Tipos anidados

Tipo Definición
InnerView (privado) ranges:: adjacent_view < V, N >
( tipo de miembro solo para exposición* )
inner_iterator (privado)
inner_sentinel (privado)

Miembros de datos

Miembro Descripción
/*movable-box*/ < F > fun_ (privado) el objeto invocable de transformación
( objeto miembro solo para exposición* )
ranges:: adjacent_view < V,N > inner_ (privado) la vista almacenada
( objeto miembro solo para exposición* )

Clases anidadas

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

Notas

views :: adjacent_transform solo acepta rangos de avance incluso cuando N es 0 .

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 <iostream>
#include <ranges>
int main()
{
    constexpr static std::array data{1, 2, 3, 4, 5, 6};
    constexpr int window{3};
    auto Fun = [](auto... ints) { return (... + ints); };
    // Alternativamente, Fun podría ser cualquier objeto llamable ternario (si window == 3), por ejemplo:
    // auto Fun = [](int x, int y, int z) { return x + y + z; };
    constexpr auto view = data | std::views::adjacent_transform<window>(Fun);
    static_assert(
        view.size() == (data.size() - window + 1)
        && std::array{6, 9, 12, 15}
        == std::array{view[0], view[1], view[2], view[3]}
        && view[0] == Fun(data[0], data[1], data[2])
        && view[1] == Fun(data[1], data[2], data[3])
        && view[2] == Fun(data[2], data[3], data[4])
        && view[3] == Fun(data[3], data[4], data[5])
    );
    for (int x : view)
        std::cout << x << ' ';
    std::cout << '\n';
}

Salida: 

6 9 12 15

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_transform < 0 > aceptaba rangos de solo entrada se rechaza

Referencias

  • Estándar C++23 (ISO/IEC 14882:2024):
  • 26.7.27 Vista de transformación adyacente [range.adjacent.transform]

Véase también

(C++23)
una view que consiste en tuplas de referencias a elementos adyacentes de la vista adaptada
(plantilla de clase) (objeto adaptador de rango)
(C++20)
una view de una secuencia que aplica una función de transformación a cada elemento
(plantilla de clase) (objeto adaptador de rango)
(C++23)
una view que consiste en los resultados de la aplicación de una función de transformación a elementos correspondientes de las vistas adaptadas
(plantilla de clase) (objeto de punto de personalización)
(C++20)
aplica una función a un rango de elementos
(objeto función algoritmo)