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
Défini dans l'en-tête <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) (depuis C++23)
namespace views {

inline constexpr /* non spécifié */ chunk_by = /* non spécifié */ ;

}
(2) (depuis C++23)
Signature d'appel
template < ranges:: viewable_range R, class Pred >

requires /* voir ci-dessous */

constexpr ranges:: view auto chunk_by ( R && r, Pred && pred ) ;
(depuis C++23)
template < class Pred >
constexpr /*adaptateur de plage*/ chunk_by ( Pred && pred ) ;
(depuis C++23)
1) chunk_by_view est un adaptateur de gamme qui prend une view et un objet invocable pred (le prédicat binaire), et produit une view de sous-gammes (tronçons), en divisant la vue sous-jacente entre chaque paire d'éléments adjacents pour laquelle pred retourne false . Le premier élément de chaque telle paire appartient au tronçon précédent, et le second élément appartient au tronçon suivant.
2) Le nom views :: chunk_by désigne un RangeAdaptorObject . Étant donné une sous-expression e et f , l'expression views :: chunk_by ( e, f ) est équivalente en expression à chunk_by_view ( e, f ) .

chunk_by_view modélise toujours forward_range , et modélise bidirectional_range et/ou common_range , si la view adaptée modélise les concepts correspondants. chunk_by_view ne modélise jamais borrowed_range ou sized_range .

Table des matières

Membres de données

Membre Définition
V base_ la vue sous-jacente view
( objet membre d'exposition uniquement* )
movable-box <Pred> pred_ un objet qui encapsule le prédicat utilisé pour diviser les éléments de base_
( objet membre d'exposition uniquement* )
non-propagating-cache <iterator> begin_ un objet qui met en cache l'itérateur vers le premier élément
( objet membre d'exposition uniquement* )

Fonctions membres

construit un chunk_by_view
(fonction membre publique)
retourne une copie de la vue sous-jacente (adaptée)
(fonction membre publique)
retourne une référence au prédicat stocké
(fonction membre publique)
retourne un itérateur vers le début
(fonction membre publique)
retourne un itérateur ou un sentinelle vers la fin
(fonction membre publique)
retourne un itérateur vers le début du sous-intervalle suivant
( fonction membre d'exposition uniquement* )
retourne un itérateur vers le début du sous-intervalle précédent
( fonction membre d'exposition uniquement* )
Hérité de std::ranges::view_interface
retourne si la vue dérivée est vide, fourni uniquement si elle satisfait sized_range ou forward_range
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un itérateur constant vers le début de l'intervalle
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un sentinelle pour l'itérateur constant de l'intervalle
(fonction membre publique de std::ranges::view_interface<D> )
retourne si la vue dérivée n'est pas vide, fourni uniquement si ranges::empty lui est applicable
(fonction membre publique de std::ranges::view_interface<D> )
retourne le premier élément de la vue dérivée, fourni si elle satisfait forward_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le dernier élément de la vue dérivée, fourni uniquement si elle satisfait bidirectional_range et common_range
(fonction membre publique de std::ranges::view_interface<D> )

Guides de déduction

Classes imbriquées

le type d'itérateur
( classe de membre de modèle uniquement à titre d'exposition* )

Notes

Afin de fournir la complexité temporelle amortie constante requise par le concept range , le résultat de begin() est mis en cache dans l'objet chunk_by_view . Si la plage sous-jacente est modifiée après le premier appel à begin() , les utilisations ultérieures de l'objet chunk_by_view pourraient avoir un comportement non intuitif.

Macro de test de fonctionnalité Valeur Norme Fonctionnalité
__cpp_lib_ranges_chunk_by 202202L (C++23) std::ranges::chunk_by_view

Exemple

Exécuter ce code 
#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, "");
}

Sortie : 

[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] [ß] [水] [🍌]

Références

  • Norme C++23 (ISO/CEI 14882:2024) :
  • 26.7.30 Vue de regroupement par [range.chunk.by]

Voir aussi

(C++23)
une plage de view s qui sont des blocs successifs non chevauchants de taille N des éléments d'une autre view
(modèle de classe) (objet adaptateur de plage)
(C++23)
une view dont le M ème élément est une view sur les éléments M ème à (M + N - 1) ème d'une autre view
(modèle de classe) (objet adaptateur de plage)
(C++23)
une view constituée d'éléments d'une autre view , avançant de N éléments à la fois
(modèle de classe) (objet adaptateur de plage)