Namespaces
Variants

std::ranges:: views:: chunk_by, std::ranges:: chunk_by_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::chunk_by_view
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 /* no especificado */ chunk_by = /* no especificado */ ;

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

requires /* ver más abajo */

constexpr ranges:: view auto chunk_by ( R && r, Pred && pred ) ;
(desde C++23)
template < class Pred >
constexpr /*cierre adaptador de rango*/ chunk_by ( Pred && pred ) ;
(desde C++23)
1) chunk_by_view es un adaptador de rango que toma una view y un objeto invocable pred (el predicado binario), y produce una view de subrangos (chunks), dividiendo la vista subyacente entre cada par de elementos adyacentes para los cuales pred devuelve false . El primer elemento de cada par pertenece al chunk anterior, y el segundo elemento pertenece al siguiente chunk.
2) El nombre views :: chunk_by denota un RangeAdaptorObject . Dada una subexpresión e y f , la expresión views :: chunk_by ( e, f ) es equivalente-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 view adaptado modela los conceptos correspondientes. chunk_by_view nunca modela borrowed_range o sized_range .

Contenidos

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 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> )

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)
(C++23)
una view que consiste en elementos de otra view , avanzando N elementos a la vez
(plantilla de clase) (objeto adaptador de rango)