std::ranges:: views:: slide, std::ranges:: slide_view
|
Défini dans l'en-tête
<ranges>
|
||
|
template
<
ranges::
forward_range
V
>
requires
ranges::
view
<
V
>
|
(1) | (depuis C++23) |
|
namespace
views
{
inline
constexpr
/* non spécifié */
slide
=
/* non spécifié */
;
|
(2) | (depuis C++23) |
|
Signature d'appel
|
||
|
template
<
ranges::
viewable_range
R
>
constexpr ranges:: view auto slide ( R && r, ranges:: range_difference_t < R > n ) ; |
(depuis C++23) | |
|
template
<
class
DifferenceType
>
constexpr /* objet adaptateur de plage */ slide ( DifferenceType && n ) ; |
(depuis C++23) | |
|
Concepts auxiliaires
|
||
|
template
<
class
V
>
concept
/*slide-caches-nothing*/
=
|
(3) | ( exposition uniquement* ) |
|
template
<
class
V
>
concept
/*slide-caches-last*/
=
|
(4) | ( exposition uniquement* ) |
|
template
<
class
V
>
concept
/*slide-caches-first*/
=
|
(5) | ( exposition uniquement* ) |
slide_view
est un adaptateur de gamme qui prend une
view
et un nombre
n
et produit une vue dont le
m
ème
élément (une « fenêtre ») est une vue sur
[
m
,
m + n - 1
]
éléments de la vue originale.
- s - n + 1 , si s >= n ,
- 0 sinon, et la vue résultante est vide.
Si n n'est pas supérieur à 0 , le comportement est indéfini.
slide_view
modélise toujours
forward_range
, et modélise
bidirectional_range
,
random_access_range
, ou
sized_range
si la
view
adaptée modélise le concept correspondant.
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 de la « fenêtre »
( objet membre d'exposition uniquement* ) |
non-propagating-cache
<
ranges::
iterator_t
<
V
>>
cached_begin_
(présent uniquement si
V
modélise
slide-caches-first
)
|
un objet qui met en cache le résultat de
begin()
( objet membre d'exposition uniquement* ) |
non-propagating-cache
<
ranges::
iterator_t
<
V
>>
cached_end_
(présent uniquement si
V
modélise
slide-caches-last
)
|
un objet qui met en cache le résultat de
end()
( objet membre d'exposition uniquement* ) |
Fonctions membres
construit un
slide_view
(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
( classe membre template d'exposition uniquement* ) |
|
(C++23)
|
le type sentinelle utilisé lorsque
slide_view
n'est pas une
common_range
( classe membre template d'exposition uniquement* ) |
Modèles d'assistance
|
template
<
class
V
>
constexpr
bool
ranges::
enable_borrowed_range
<
slide_view
<
V
>>
=
|
(depuis C++23) | |
Cette spécialisation de
ranges::enable_borrowed_range
permet à
slide_view
de satisfaire
borrowed_range
lorsque la vue sous-jacente la satisfait.
Notes
Il existe des similitudes entre ranges::adjacent_view et ranges::slide_view :
-
Les deux créent une « fenêtre glissante » de taille
N. -
Les deux ont la même taille
S - N + 1, oùSest la taille d'uneviewadaptée telle queS >= N > 0.
Le tableau suivant montre les différences entre ces adaptateurs :
| Adaptateur de vue |
value_type
|
La taille de la fenêtre
N
|
|---|---|---|
| ranges:: adjacent_view | std::tuple | Un paramètre template |
| ranges :: slide_view | ranges:: range | Un argument d'exécution |
| Macro de test de fonctionnalité | Valeur | Std | Fonctionnalité |
|---|---|---|---|
__cpp_lib_ranges_slide
|
202202L
|
(C++23) |
std::ranges::slide_view
|
Exemple
#include <algorithm> #include <initializer_list> #include <iostream> #include <ranges> auto print_subrange = [](std::ranges::viewable_range auto&& r) { std::cout << '['; for (char space[]{0,0}; auto elem : r) std::cout << space << elem, *space = ' '; std::cout << "] "; }; int main() { const auto v = {1, 2, 3, 4, 5, 6}; std::cout << "Toutes les fenêtres glissantes de largeur :\n"; for (const unsigned width : std::views::iota(1U, 1U + v.size())) { auto const windows = v | std::views::slide(width); std::cout << "W = " << width << ": "; std::ranges::for_each(windows, print_subrange); std::cout << '\n'; } }
Sortie :
Toutes les fenêtres glissantes de largeur W : W = 1: [1] [2] [3] [4] [5] [6] W = 2: [1 2] [2 3] [3 4] [4 5] [5 6] W = 3: [1 2 3] [2 3 4] [3 4 5] [4 5 6] W = 4: [1 2 3 4] [2 3 4 5] [3 4 5 6] W = 5: [1 2 3 4 5] [2 3 4 5 6] W = 6: [1 2 3 4 5 6]
Références
- Norme C++23 (ISO/IEC 14882:2024) :
-
- 26.7.29 Vue glissante [range.slide]
Voir aussi
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 gamme de
view
s
qui sont des segments successifs non chevauchants de taille
N
des éléments d'une autre
view
(modèle de classe) (objet adaptateur de gamme) |