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

Definido en el encabezado `<ranges>`
template< ranges::forward_range V, std::move_constructible F, std::size_t N > requires 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 /* unspecified / adjacent_transform = / unspecified */; }	(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 > requires /* see below */ constexpr ranges::view auto adjacent_transform<N>( R&& r, F&& fun );		(desde C++23)
template< class F > constexpr /range adaptor closure/ adjacent_transform<N>( F&& fun );		(desde C++23)

1) adjacent_transform_view es un adaptador de rango que toma una vista y un objeto invocable fun, y produce una vista cuyo i^ésimo elemento es un valor que es el resultado 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 de lo 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 expression-equivalente a:

((void)e, views::zip_transform(f)), si N es igual a 0 y decltype((e)) modela forward_range (excepto que las evaluaciones de e y f están secuenciadas de manera indeterminada),
adjacent_transform_view<views::all_t<decltype((e))>, std::decay_t<decltype((f))>, N>(e, f) en caso contrario.

3) El nombre views::pairwise_transform denota un RangeAdaptorObject que se comporta exactamente como views::adjacent_transform<2>. En particular, la aridad de F es también 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 el tipo de vista adaptada modela el concepto correspondiente.

Funciones miembro

(constructor)	construye un `adjacent_transform_view` (función miembro pública)
begin	devuelve un iterador al inicio (función miembro pública)
end	devuelve un iterador o un centinela al final (función miembro pública)
size	devuelve el número de elementos, proporcionado solo si el rango subyacente (adaptado) satisface `sized_range` (función miembro pública)
reserve_hint (C++26)	devuelve el tamaño aproximado del `approximately_sized_range` resultante (función miembro pública)
Heredado de ranges::view_interface
empty	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>`)
cbegin (C++23)	devuelve un iterador constante al inicio del rango (función miembro pública de `std::ranges::view_interface<D>`)
cend (C++23)	devuelve un centinela para el iterador constante del rango (función miembro pública de `std::ranges::view_interface<D>`)
operator bool	devuelve si la vista derivada no está vacía, solo si ranges::empty es aplicable a ella (función miembro pública de `std::ranges::view_interface<D>`)
front	devuelve el primer elemento de la vista derivada, si satisface `forward_range` (función miembro pública de `std::ranges::view_interface<D>`)
back	devuelve el último elemento de la vista derivada, solo si satisface `bidirectional_range` y `common_range` (función miembro pública de `std::ranges::view_interface<D>`)
operator[]	devuelve el `n`^ésimo elemento de la vista derivada, 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)	ranges:: iterator_t < const InnerView > , si `Const` es true . De lo contrario, ranges:: iterator_t < InnerView > ( tipo de miembro solo para exposición* )
`inner_sentinel` (privado)	ranges:: sentinel_t < const InnerView > , si `Const` es true . De lo contrario, ranges:: sentinel_t < InnerView > ( tipo de miembro solo para exposición* )

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

iterator	el tipo de iterador ( clase de plantilla miembro solo para exposición* )
sentinel	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

ranges::adjacent_view views::adjacent (C++23)	una `view` que consiste en tuplas de referencias a elementos adyacentes de la vista adaptada (plantilla de clase) (objeto adaptador de rango)
ranges::transform_view views::transform (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)
ranges::zip_transform_view views::zip_transform (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)
ranges::transform (C++20)	aplica una función a un rango de elementos (objeto función algoritmo)

Soporte del compilador
Independiente y alojado
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos nombrados
Macros de prueba de características (C++20)
Biblioteca de soporte de lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnóstico
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de utilidades generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de soporte de concurrencia (C++11)
Biblioteca de control de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

Funciones miembro
adjacent_transform_view::adjacent_transform_view
adjacent_transform_view::begin
adjacent_transform_view::end
adjacent_transform_view::size
adjacent_transform_view::reserve_hint (C++26)
Iterador
Funciones miembro
adjacent_transform_view::iterator::iterator
adjacent_transform_view::iterator::operator*
adjacent_transform_view::iterator::operator[]
adjacent_transform_view::iterator::operator++ adjacent_transform_view::iterator::operator++(int) adjacent_transform_view::iterator::operator-- adjacent_transform_view::iterator::operator--(int) adjacent_transform_view::iterator::operator+= adjacent_transform_view::iterator::operator-=
Funciones no miembro
operator==(adjacent_transform_view::iterator) operator<(adjacent_transform_view::iterator) operator>(adjacent_transform_view::iterator) operator<=(adjacent_transform_view::iterator) operator>=(adjacent_transform_view::iterator) operator<=>(adjacent_transform_view::iterator)
operator+(adjacent_transform_view::iterator) operator-(adjacent_transform_view::iterator)
Centinela
Funciones miembro
adjacent_transform_view::sentinel::sentinel
Funciones no miembro
operator==(adjacent_transform_view::iterator,adjacent_transform_view::sentinel)
operator-(adjacent_transform_view::iterator,adjacent_transform_view::sentinel)

es.cppreference.net

Namespaces

Variants