std::ranges::views::zip, std::ranges::zip_view
| Definido en el encabezado <ranges>
|
||
template< ranges::input_range... Views >
requires (ranges::view<Views> && ...) && (sizeof...(Views) > 0)
class zip_view
: public ranges::view_interface<zip_view<Views...>>
|
(1) | (desde C++23) |
namespace views {
inline constexpr /*unspecified*/ zip = /*unspecified*/;
}
|
(2) | (desde C++23) |
| Signatura de llamada |
||
template< ranges::viewable_range... Rs >
requires /* see below */
constexpr ranges::view auto zip( Rs&&... rs );
|
(desde C++23) | |
zip_view es un adaptador de rango que toma una o más vistas, y produce una vista cuyo i-ésimo elemento es un valor similar a una tupla que consiste en los i-ésimos elementos de todas las vistas. El tamaño de la vista producida es el mínimo de los tamaños de todas las vistas adaptadas.views::zip es un objeto de punto de personalización.Al llamar sin argumento, views::zip() es equivalente a expresión a auto(views::empty<std::tuple<>>).
De lo contrario, views::zip(rs...) es equivalente a expresión a ranges::zip_view<views::all_t<decltype((rs))>...>(rs...).
zip_view siempre modela input_range, y modela forward_range, bidirectional_range, random_access_range, o sized_range si todos los tipos de vista adaptados modelan el concepto correspondiente.
zip_view modela common_range si
sizeof...(Views)es igual a1, y el único tipo de vista adaptado modela common_range, o- al menos un tipo de vista adaptado no modela bidirectional_range, y cada tipo de vista adaptado modela common_range, o
- cada tipo de vista adaptado modela tanto random_access_range como sized_range.
Objetos de punto de personalización
El nombre
views::zip
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.
Miembros de datos
| Miembro | Descripción |
std::
tuple
<
Views...
>
views_
|
todos los objetos de vista adaptados
( objeto miembro solo para exposición* ) |
Funciones miembro
construye un
zip_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 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, solo si cumple con 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, 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, si cumple con forward_range (función miembro pública de std::ranges::view_interface<D>)
| |
| devuelve el último elemento en la vista derivada, solo si cumple con 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, solo si cumple con random_access_range (función miembro pública de std::ranges::view_interface<D>)
| |
Guías de deducción
Clases anidadas
|
el tipo de iterador
( clase de plantilla miembro solo para exposición* ) |
|
el tipo de centinela utilizado cuando
zip_view
no es un
common_range
( clase de plantilla miembro solo para exposición* ) |
Plantillas auxiliares
|
template
<
class
...
Views
>
constexpr
bool
enable_borrowed_range
<
ranges
::
zip_view
<
Views...
>>
=
|
(desde C++23) | |
Esta especialización de
ranges::enable_borrowed_range
hace que
zip_view
satisfaga
borrowed_range
cuando cada vista subyacente la satisface.
Notas
| Macro de prueba de características | Valor | Estándar | Característica |
|---|---|---|---|
__cpp_lib_ranges_zip
|
202110L
|
(C++23) |
ranges::zip_view
,
ranges:: zip_transform_view , ranges:: adjacent_view , ranges:: adjacent_transform_view |
Ejemplo
#include <array> #include <iostream> #include <list> #include <ranges> #include <string> #include <tuple> #include <vector> void print(auto const rem, auto const& range) { for (std::cout << rem; auto const& elem : range) std::cout << elem << ' '; std::cout << '\n'; } int main() { auto x = std::vector{1, 2, 3, 4}; auto y = std::list<std::string>{"α", "β", "γ", "δ", "ε"}; auto z = std::array{'A', 'B', 'C', 'D', 'E', 'F'}; print("Vistas fuente:", ""); print("x: ", x); print("y: ", y); print("z: ", z); print("\nzip(x,y,z):", ""); for (std::tuple<int&, std::string&, char&> elem : std::views::zip(x, y, z)) { std::cout << std::get<0>(elem) << ' ' << std::get<1>(elem) << ' ' << std::get<2>(elem) << '\n'; std::get<char&>(elem) += ('a' - 'A'); // modifica el elemento de z } print("\nDespués de la modificación, z: ", z); }
Salida:
Vistas fuente: x: 1 2 3 4 y: α β γ δ ε z: A B C D E F zip(x,y,z): 1 α A 2 β B 3 γ C 4 δ D Después de la modificación, z: a b c d E F
Véase también
una
view
que consiste en los resultados de la aplicación de una función de transformación a los elementos correspondientes de las vistas adaptadas
(plantilla de clase) (objeto de punto de personalización) |
|
toma una
view
que consiste en valores
tuple-like
y un número N, y produce una
view
del N
ésimo
elemento de cada tupla
(plantilla de clase) (objeto adaptador de rango) |