std::ranges::views::chunk_by, std::ranges::chunk_by_view
De es.cppreference.net
| Definido en el encabezado <ranges>
|
||
template< ranges::forward_range V, std::indirect_binary_predicate<iterator_t<V>,
ranges::iterator_t<V>> Pred >
requires ranges::view<V> && std::is_object_v<Pred>
class chunk_by_view
: public ranges::view_interface<chunk_by_view<V, Pred>>
|
(1) | (desde C++23) |
namespace views {
inline constexpr /* unspecified */ chunk_by = /* unspecified */ ;
}
|
(2) | (desde C++23) |
| Firma de llamada |
||
template< ranges::viewable_range R, class Pred >
requires /* see below */
constexpr ranges::view auto chunk_by( R&& r, Pred&& pred );
|
(desde C++23) | |
template< class Pred >
constexpr /*range adaptor closure*/ chunk_by( Pred&& pred );
|
(desde C++23) | |
1)
chunk_by_view es un adaptador de rango que toma una vista y un objeto invocable pred (el predicado binario), y produce una vista de subrangos (fragmentos), dividiendo la vista subyacente entre cada par de elementos adyacentes para los cuales pred devuelve false. El primer elemento de cada par pertenece al fragmento anterior, y el segundo elemento pertenece al siguiente fragmento.2) El nombre
views::chunk_by denota un ObjetoAdaptadorDeRango. Dada una subexpresión e y f, la expresión views::chunk_by(e, f) es equivalente en expresión a chunk_by_view(e, f).chunk_by_view siempre modela forward_range, y modela bidirectional_range y/o common_range, si el tipo de vista adaptada modela los conceptos correspondientes.
chunk_by_view nunca modela borrowed_range o sized_range.
Miembros de datos
| Miembro | Definición |
V
base_
|
la
view
subyacente
( objeto miembro solo para exposición* ) |
movable-box
<Pred>
pred_
|
un objeto que encapsula el predicado utilizado para dividir los elementos de
base_
( objeto miembro solo para exposición* ) |
non-propagating-cache
<iterator>
begin_
|
un objeto que almacena en caché el iterador al primer elemento
( objeto miembro solo para exposición* ) |
Funciones miembro
construye un
chunk_by_view
(función miembro pública) |
|
|
devuelve una copia de la vista subyacente (adaptada)
(función miembro pública) |
|
|
devuelve una referencia al predicado almacenado
(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 un iterador al inicio del siguiente subrango
( función miembro solo para exposición* ) |
|
|
devuelve un iterador al inicio del subrango anterior
( función miembro solo para exposición* ) |
|
Heredado de ranges::view_interface | |
| 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>)
| |
(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, solo si satisface forward_range (función miembro pública de std::ranges::view_interface<D>)
| |
| devuelve el último elemento en la vista derivada, solo si satisface bidirectional_range y common_range (función miembro pública de std::ranges::view_interface<D>)
| |
Guías de deducción
Clases anidadas
|
el tipo de iterador
( clase plantilla de miembro solo para exposición* ) |
Notas
Para proporcionar la complejidad temporal amortizada constante requerida por el concepto
range
, el resultado de
begin()
se almacena en caché dentro del objeto
chunk_by_view
. Si el rango subyacente se modifica después de la primera llamada a
begin()
, los usos posteriores del objeto
chunk_by_view
podrían tener un comportamiento no intuitivo.
| Macro de prueba de características | Valor | Estándar | Característica |
|---|---|---|---|
__cpp_lib_ranges_chunk_by
|
202202L
|
(C++23) |
std::ranges::chunk_by_view
|
Ejemplo
Ejecutar este código
#include <functional> #include <iostream> #include <ranges> #include <string_view> void print_chunks(auto view, std::string_view separator = ", ") { for (auto const subrange : view) { std::cout << '['; for (std::string_view prefix; auto const& elem : subrange) std::cout << prefix << elem, prefix = separator; std::cout << "] "; } std::cout << '\n'; } int main() { std::initializer_list v1 = {1, 2, 3, 1, 2, 3, 3, 3, 1, 2, 3}; auto fn1 = std::ranges::less{}; auto view1 = v1 | std::views::chunk_by(fn1); print_chunks(view1); std::initializer_list v2 = {1, 2, 3, 4, 4, 0, 2, 3, 3, 3, 2, 1}; auto fn2 = std::ranges::not_equal_to{}; auto view2 = v2 | std::views::chunk_by(fn2); print_chunks(view2); std::string_view v3 = "__cpp_lib_ranges_chunk_by"; auto fn3 = [](auto x, auto y) { return not(x == '_' or y == '_'); }; auto view3 = v3 | std::views::chunk_by(fn3); print_chunks(view3, ""); std::string_view v4 = "\u007a\u00df\u6c34\u{1f34c}"; // "zß水🍌" auto fn4 = [](auto, auto ß) { return 128 == ((128 + 64) & ß); }; auto view4 = v4 | std::views::chunk_by(fn4); print_chunks(view4, ""); }
Salida:
[1, 2, 3] [1, 2, 3] [3] [3] [1, 2, 3] [1, 2, 3, 4] [4, 0, 2, 3] [3] [3, 2, 1] [_] [_] [cpp] [_] [lib] [_] [ranges] [_] [chunk] [_] [by] [z] [ß] [水] [🍌]
Referencias
- Estándar C++23 (ISO/IEC 14882:2024):
-
- 26.7.30 Vista de fragmentación por [range.chunk.by]
Véase también
|
(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
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) |
una
view
que consiste en elementos de otra
view
, avanzando N elementos a la vez
(plantilla de clase) (objeto adaptador de rango) |