Namespaces
Variants

std::ranges:: views:: slide, std::ranges:: slide_view

From cppreference.net
Ranges library
Range adaptors
Défini dans l'en-tête <ranges>
template < ranges:: forward_range V >

requires ranges:: view < V >
class slide_view

: public ranges:: view_interface < slide_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*/ =

ranges:: random_access_range < V > && ranges:: sized_range < V > ;
(3) ( exposition uniquement* )
template < class V >

concept /*slide-caches-last*/ =
! /*slide-caches-nothing*/ < V > &&

ranges:: bidirectional_range < V > && ranges:: common_range < V > ;
(4) ( exposition uniquement* )
template < class V >

concept /*slide-caches-first*/ =

! /*slide-caches-nothing*/ < V > && ! /*slide-caches-last*/ < V > ;
(5) ( exposition uniquement* )
1) 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.
Soit s la taille de la vue originale. Alors la taille de la vue produite est :
  • s - n + 1 , si s >= n ,
  • 0 sinon, et la vue résultante est vide.
2) Le nom views :: slide désigne un RangeAdaptorObject . Étant données les sous-expressions e et n , l'expression views :: slide ( e, n ) est équivalente en expression à slide_view ( e, n ) .

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)
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 >> =

ranges:: enable_borrowed_range < 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ù S est la taille d'une view adaptée telle que S >= 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)
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)