std::ranges::views::zip_transform, std::ranges::zip_transform_view
De es.cppreference.net
| Definido en el encabezado <ranges>
|
||
template< std::move_constructible F, ranges::input_range... Views >
requires (ranges::view<Views> && ...) && (sizeof...(Views) > 0) &&
std::is_object_v<F> && std::regular_invocable<
F&, ranges::range_reference_t<Views>...> &&
/*can-reference*/<std::invoke_result_t<
F&, ranges::range_reference_t<Views>...>>
class zip_transform_view
: public ranges::view_interface<zip_transform_view<F, Views...>>
|
(1) | (desde C++23) |
namespace views {
inline constexpr /*unspecified*/ zip_transform = /*unspecified*/;
}
|
(2) | (desde C++23) |
| Firma de llamada |
||
template< class F, ranges::viewable_range... Rs >
requires /* see below */
constexpr auto zip_transform( F&& f, Rs&&... rs );
|
(desde C++23) | |
1)
Un tipo
zip_transform_view es un adaptador de rango que toma un objeto invocable y una o más views, y produce una view cuyo i-ésimo elemento es el resultado de aplicar el objeto invocable a los i-ésimos elementos de todas las vistas.Un tipo
T modela el concepto de solo exposición /*can-reference*/ si y solo si T& es un tipo válido.2)
views::zip_transform es un objeto de punto de personalización.
Al llamar con un argumento f, sea FD igual a std::decay_t<decltype(f)>, si:
FDmodela copy_constructible,FD&modela regular_invocable, ystd::invoke_result_t<FD&>es un tipo objeto,
entonces views::zip_transform(f) es equivalente-expresión a ((void)f, auto(views::empty<std::decay_t<std::invoke_result_t<FD&>>>)). De lo contrario, la llamada a views::zip_transform está mal formada.
f y rs..., views::zip_transform(f, rs...) es equivalente-expresión a ranges::zip_transform_view(f, rs...).zip_transform_view modela los conceptos random_access_range, bidirectional_range, forward_range, input_range, common_range y sized_range cuando la ranges::zip_view<Views...> subyacente modela los conceptos respectivos.
Objetos de punto de personalización
El nombre
views::zip_transform
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.
Funciones miembro
construye un
zip_transform_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 cada rango subyacente (adaptado) satisface
sized_range
(función miembro pública) |
|
Heredado de 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
Tipos miembro
| Tipo | Definición |
InnerView (privado)
|
ranges::zip_view<Views...>.(tipo miembro solo para exposición*) |
ziperator (privado)
|
|
zentinel (privado)
|
|
Miembros de datos
| Miembro | Descripción |
InnerView zip_ (privado)
|
un objeto de vista subyacente (objeto miembro solo de exposición*) |
caja móvil<F> fun_ (privado)
|
un objeto invocable envuelto (objeto miembro solo de exposición*) |
Clases anidadas
|
el tipo de iterador
( clase de miembro plantilla solo para exposición* ) |
|
el tipo de centinela utilizado cuando el
zip_view
subyacente no es un
common_range
( clase de miembro plantilla solo para exposición* ) |
Notas
| Macro de prueba de características | Valor | Std | Característica |
|---|---|---|---|
__cpp_lib_ranges_zip
|
202110L
|
(C++23) |
ranges::
zip_view
,
std::ranges::zip_transform_view
,
ranges:: adjacent_view , ranges:: adjacent_transform_view |
Ejemplo
Ejecutar este código
#include <array> #include <iostream> #include <list> #include <ranges> #include <vector> void print(auto const rem, auto const& r) { std::cout << rem << '{'; for (char o[]{0,' ',0}; auto const& e : r) std::cout << o << e, *o = ','; std::cout << "}\n"; } int main() { auto v1 = std::vector<float>{1, 2, 3}; auto v2 = std::list<short>{1, 2, 3, 4}; auto v3 = std::to_array({1, 2, 3, 4, 5}); auto add = [](auto a, auto b, auto c) { return a + b + c; }; auto sum = std::views::zip_transform(add, v1, v2, v3); print("v1: ", v1); print("v2: ", v2); print("v3: ", v3); print("sum: ", sum); }
Salida:
v1: {1, 2, 3}
v2: {1, 2, 3, 4}
v3: {1, 2, 3, 4, 5}
sum: {3, 6, 9}
Véase también
(C++23) |
una vista que consiste en tuplas de referencias a los elementos correspondientes de las vistas adaptadas (plantilla de clase) (objeto punto de personalización) |
| una vista de una secuencia que aplica una función de transformación a cada elemento (plantilla de clase) (objeto adaptador de rango) | |
| toma una vista que consiste en valores similares a tuplas y un número N y produce una vista del N-ésimo elemento de cada tupla (plantilla de clase) (objeto adaptador de rango) |