std::ranges::views::stride, std::ranges::stride_view
Depuis fr.cppreference.net
| Défini dans l'en-tête <ranges>
|
||
template< ranges::input_range V >
requires ranges::view<V>
class stride_view
: public ranges::view_interface<stride_view<V>>
|
(1) | (depuis C++23) |
namespace views {
inline constexpr /* unspecified */ stride = /* unspecified */;
}
|
(2) | (depuis C++23) |
| Signature d'appel |
||
template< ranges::viewable_range R >
constexpr ranges::view auto stride( R&& r, ranges::range_difference_t<R> n );
|
(depuis C++23) | |
template< class DifferenceType >
constexpr /*range adaptor closure*/ stride( DifferenceType&& n );
|
(depuis C++23) | |
| Gabarits d'aide |
||
1)
stride_view est un adaptateur de plage qui prend une vue (view) et un nombre n et produit une vue constituée des éléments de la vue originale en avançant de n éléments à la fois. Cela signifie que chaque mi-ème élément de la vue produite est le (n * i)j-ème élément de la vue originale, pour un certain indice non négatif i.
Les éléments de la vue originale dont l'indice n'est pas un multiple de n ne sont pas présents dans la vue produite. Soit
S la taille de la vue originale. Alors la taille de la vue produite est :
(S / n) + (S % n ? 1 : 0), siS >= n; sinon,1, siS > 0; sinon,0, et la vue résultante est vide.
2) Le nom
views::stride désigne un ObjetAdaptateurDePlage (RangeAdaptorObject). Étant donné les sous-expressions e et n, l'expression views::stride(e, n) est équivalente à une expression à stride_view(e, n). Le
n doit être supérieur à 0, sinon le comportement est indéfini.stride_view modélise toujours input_range, et modélise forward_range, bidirectional_range, random_access_range, et/ou sized_range, si le type de la vue (view) adaptée V modélise le concept correspondant.
stride_view<V> modélise common_range chaque fois que la vue sous-jacente V le fait.
Membres de données
| Membre | Description |
V
base_
|
la vue sous-jacente
( objet membre d'exposition uniquement* ) |
ranges::
range_difference_t
<
V
>
stride_
|
l'objet de taille (le "stride")
( objet membre d'exposition uniquement* ) |
Fonctions membres
construit un
stride_view
(fonction membre publique) |
|
|
(C++23)
|
retourne la valeur de stride stockée
(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ée de ranges::view_interface | |
| renvoie si la vue dérivée est vide, fournie 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 au début de la plage (fonction membre publique de std::ranges::view_interface<D>)
|
(C++23) |
renvoie un 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, fournie uniquement si ranges::empty lui est applicable (fonction membre publique de std::ranges::view_interface<D>)
| |
| renvoie le premier élément de la vue dérivée, fournie si elle satisfait forward_range (fonction membre publique de std::ranges::view_interface<D>)
| |
| renvoie le dernier élément de la vue dérivée, fournie uniquement si elle satisfait bidirectional_range et common_range (fonction membre publique de std::ranges::view_interface<D>)
| |
renvoie le nième élément de la vue dérivée, fournie 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 ) |
Modèles d'assistance
|
template
<
class
V
>
constexpr
bool
ranges::
enable_borrowed_range
<
stride_view
<
V
>>
=
|
(depuis C++23) | |
Cette spécialisation de
ranges::enable_borrowed_range
permet à
stride_view
de satisfaire
borrowed_range
lorsque la vue sous-jacente la satisfait.
Notes
| Macro de test de fonctionnalité | Valeur | Std | Fonctionnalité |
|---|---|---|---|
__cpp_lib_ranges_stride
|
202207L
|
(C++23) |
std::ranges::stride_view
|
Exemple
Exécuter ce code
#include <algorithm> #include <iostream> #include <ranges> #include <string_view> using namespace std::literals; void print(std::ranges::viewable_range auto&& v, std::string_view separator = " ") { for (auto const& x : v) std::cout << x << separator; std::cout << '\n'; } int main() { print(std::views::iota(1, 13) | std::views::stride(3)); print(std::views::iota(1, 13) | std::views::stride(3) | std::views::reverse); print(std::views::iota(1, 13) | std::views::reverse | std::views::stride(3)); print("0x0!133713337*x//42/A$@"sv | std::views::stride(0B11) | std::views::transform([](char O) -> char { return 0100 | O; }), ""); }
Sortie :
1 4 7 10 10 7 4 1 12 9 6 3 password
Références
- Norme C++23 (ISO/IEC 14882:2024) :
-
- 26.7.31 Vue de pas [range.stride]
Voir aussi
|
(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) |
|
(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) |
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) |
|
une
view
qui consiste en les éléments d'un
range
qui satisfont un prédicat
(modèle de classe) (objet adaptateur de gamme) |