std::ranges::views::chunk_by, std::ranges::chunk_by_view
De fr.cppreference.net
| 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 /* unspecified */ chunk_by = /* unspecified */ ;
}
|
(2) | (depuis C++23) |
| Signature d'appel |
||
template< ranges::viewable_range R, class Pred >
requires /* see below */
constexpr ranges::view auto chunk_by( R&& r, Pred&& pred );
|
(depuis C++23) | |
template< class Pred >
constexpr /*range adaptor closure*/ chunk_by( Pred&& pred );
|
(depuis C++23) | |
1)
chunk_by_view est un adaptateur de plage qui prend une view et un objet invocable pred (le prédicat binaire), et produit une view de sous-plages (morceaux), en divisant la vue sous-jacente entre chaque paire d'éléments adjacents pour laquelle pred retourne false. Le premier élément de chaque paire appartient au morceau précédent, et le second élément appartient au morceau 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 le type de view adapté modélise les concepts correspondants.
chunk_by_view ne modélise jamais borrowed_range ou sized_range.
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 ranges::view_interface | |
| renvoie si la vue dérivée est vide, uniquement si elle satisfait sized_range ou forward_range (fonction membre publique de std::ranges::view_interface<D>)
| |
(C++23) |
renvoie un itérateur constant vers le début de la plage (fonction membre publique de std::ranges::view_interface<D>)
|
(C++23) |
renvoie une sentinelle pour l'itérateur constant de la plage (fonction membre publique de std::ranges::view_interface<D>)
|
| renvoie si la vue dérivée n'est pas vide, uniquement si ranges::empty lui est applicable (fonction membre publique de std::ranges::view_interface<D>)
| |
| renvoie le premier élément dans la vue dérivée, si elle satisfait forward_range (fonction membre publique de std::ranges::view_interface<D>)
| |
| renvoie le dernier élément dans la vue dérivée, 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) |
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) |