Namespaces
Variants

std::ranges:: views:: chunk, std::ranges:: chunk_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::chunk_view
Member functions
(C++26)
Classes for input_range s
Deduction guides
outer-iterator
outer-iterator ::value_type
inner-iterator
Défini dans l'en-tête <ranges>
template < ranges:: view V >

requires ranges:: input_range < V >
class chunk_view

: public ranges:: view_interface < chunk_view < V >>
(1) (depuis C++23)
template < ranges:: view V >

requires ranges:: forward_range < V >
class chunk_view < V >

: public ranges:: view_interface < chunk_view < V >>
(2) (depuis C++23)
namespace views {

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

}
(3) (depuis C++23)
Signature d'appel
template < ranges:: viewable_range R >
constexpr ranges:: view auto chunk ( R && r, ranges:: range_difference_t < R > n ) ;
(depuis C++23)
template < class DifferenceType >
constexpr /*adaptateur de plage de fermeture*/ chunk ( DifferenceType && n ) ;
(depuis C++23)
Modèles auxiliaires
template < class I >
constexpr I /*div-ceil*/ ( I num, I denom ) ;
(4) ( exposition uniquement* )

chunk_view prend une view et un nombre n et produit une gamme de vues (les chunks  ) de la vue originale, de telle sorte que chaque chunk  , sauf peut-être le dernier, ait la taille n . Ces chunks sont des sous-intervalles non chevauchants et successifs des éléments de la vue originale, dans l'ordre.

Soit s la taille de la vue originale. Si s n'est pas un multiple de n , la taille de la dernière vue produite est exactement s % n (le reste). Sinon, la taille de chaque segment  , y compris le dernier, est n .

La taille de la vue produite est /*div-ceil*/ ( s ) .

Si le n n'est pas supérieur à ​ 0 ​ le comportement est indéfini.

1) Une implémentation qui prend en charge la vue sous-jacente V qui modélise uniquement input_range .
2) Une spécialisation partielle qui prend en charge la vue sous-jacente V qui modélise forward_range ou plus fort. Modélise common_range si la vue sous-jacente V est forward_range , common_range , et soit sized_range ou non bidirectional_range .
3) Le nom views :: chunk désigne un RangeAdaptorObject . Étant données les sous-expressions e et n , l'expression views :: chunk ( e, n ) est équivalente en expression à chunk_view ( e, n ) .
4) Calcule la plus petite valeur entière qui n'est pas inférieure au quotient de la division de num par denom . Équivalent à : 
I r = num / denom;
if (num % denom)
    ++r;
return r;

Table des matières

Membres de données

Membre Description
V base_ la vue sous-jacente
( objet membre d'exposition uniquement* )
ranges:: range_difference_t < V > n_ la taille du "morceau"
( objet membre d'exposition uniquement* )
Si V modélise exactement input_range ( 1 )
ranges:: range_difference_t < V > remainder_
(conditionnellement présent) 		le nombre d'éléments restants dans le "morceau" actuel
( objet membre d'exposition uniquement* )
non-propagating-cache < ranges:: iterator_t < V >> current_
(conditionnellement présent) 		un objet qui met en cache l'itérateur sous-jacent actuel
( objet membre d'exposition uniquement* )

Fonctions membres

construit un chunk_view
(fonction membre publique)
retourne une copie de la vue sous-jacente (adaptée)
(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 le nombre d'éléments, fourni uniquement si la plage sous-jacente (adaptée) satisfait sized_range
(fonction membre publique)
(C++26)
retourne la taille approximative de la approximately_sized_range résultante
(fonction membre publique)
Hérité de std::ranges::view_interface
indique 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 la plage
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un sentinelle pour l'itérateur constant de la plage
(fonction membre publique de std::ranges::view_interface<D> )
indique 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> )
retourne le n ème élément de la vue dérivée, fourni uniquement si elle satisfait random_access_range
(fonction membre publique de std::ranges::view_interface<D> )

Guides de déduction

Classes imbriquées

(C++23)
le type d'itérateur de sortie ("par morceaux") lorsque V modélise input_range ( 1 )
( classe membre d'exposition uniquement* )
(C++23)
le type d'itérateur interne ("élément par élément") lorsque V modélise input_range ( 1 )
( classe membre d'exposition uniquement* )
(C++23)
le type d'itérateur lorsque V modélise forward_range ( 2 )
( modèle de classe membre d'exposition uniquement* )

Modèles d'assistance

template < class V >

constexpr bool ranges:: enable_borrowed_range < chunk_view < V >> =

ranges:: forward_range < V > && ranges:: enable_borrowed_range < V > ;
(depuis C++23)

Cette spécialisation de ranges::enable_borrowed_range permet à chunk_view de satisfaire borrowed_range lorsque la vue sous-jacente V satisfait à la fois forward_range et borrowed_range .

Notes

Si V modélise input_range ( 1 ) , chunk_view a un type d'itérateur dédié : outer_iterator::value_type qui est lui-même une vue d'entrée.

Si V modélise forward_range ou plus fort ( 2 ) , chunk_view délègue à views::take pour son value_type .

Si V modélise bidirectional_range ou des gammes plus fortes ( 2 ) , la nécessité de calculer la taille du dernier segment correctement (depuis l'itérateur de fin iterator ) exige que le type de gamme sous-jacent V soit sized_range .

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_ranges_chunk 202202L (C++23) std::ranges::chunk_view

Exemple

Exécuter ce code 
#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <ranges>
auto print_subrange = [](std::ranges::viewable_range auto&& r)
{
    std::cout << '[';
    for (int pos{}; auto elem : r)
        std::cout << (pos++ ? " " : "") << elem;
    std::cout << "] ";
};
int main()
{
    const auto v = {1, 2, 3, 4, 5, 6};
    for (const unsigned width : std::views::iota(1U, 2U + v.size()))
    {
        auto const chunks = v | std::views::chunk(width);
        std::cout << "chunk(" << width << "): ";
        std::ranges::for_each(chunks, print_subrange);
        std::cout << '\n';
    }
}

Sortie : 

chunk(1): [1] [2] [3] [4] [5] [6]
chunk(2): [1 2] [3 4] [5 6]
chunk(3): [1 2 3] [4 5 6]
chunk(4): [1 2 3 4] [5 6]
chunk(5): [1 2 3 4 5] [6]
chunk(6): [1 2 3 4 5 6]
chunk(7): [1 2 3 4 5 6]

Références

  • Norme C++23 (ISO/IEC 14882:2024) :
  • 26.7.28 Vue par morceaux [range.chunk]

Voir aussi

(C++23)
divise la view en sous-intervalles entre chaque paire d'éléments adjacents pour lesquels le prédicat donné retourne false
(modèle de classe) (objet adaptateur de gamme)
(C++23)
une view constituée de tuples de références aux éléments adjacents de la vue adaptée
(modèle de classe) (objet adaptateur de gamme)
(C++23)
une view dont le M ème élément est une view sur les M ème à (M + N - 1) ème éléments d'une autre view
(modèle de classe) (objet adaptateur de gamme)