Namespaces
Variants

std::ranges:: views:: adjacent, std::ranges:: adjacent_view, std::ranges:: views:: pairwise

From cppreference.net
C++
Ranges library
Range adaptors
adjacent_view views::adjacent
(C++23) (C++23)
views::pairwise
(C++23)
(C++23) (C++23)
(C++23)
(C++23) (C++23)
(C++23) (C++23)
(C++23) (C++23)
(C++23) (C++23)
(C++23) (C++23)

std::ranges::adjacent_view
Member functions
(C++26)
Iterator
Member functions
Non-member functions
Sentinel
Member functions
Non-member functions
Défini dans l'en-tête <ranges>
template < ranges:: forward_range V, std:: size_t N >

requires ranges:: view < V > && ( N > 0 )
class adjacent_view

: public ranges:: view_interface < adjacent_view < V, N >>
(1) (depuis C++23)
namespace views {

template < std:: size_t N >
constexpr /* non spécifié */ adjacent = /* non spécifié */ ;

}
(2) (depuis C++23)
namespace views {

inline constexpr auto pairwise = adjacent < 2 > ;

}
(3) (depuis C++23)
Signature d'appel
template < ranges:: viewable_range R >

requires /* voir ci-dessous */

constexpr ranges:: view auto adjacent < N > ( R && r ) ;
(depuis C++23)
1) adjacent_view est un adaptateur de gamme qui prend une view , et produit une view dont le i ème élément (une « fenêtre ») est un std::tuple qui contient N références aux éléments [ i , i + N - 1 ] 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 :: adjacent < N > désigne un RangeAdaptorObject . Étant donné une sous-expression e et une expression constante N , l'expression views :: adjacent < N > ( e ) est équivalente à l'expression à
3) Le nom views :: pairwise désigne un RangeAdaptorObject qui se comporte exactement comme views :: adjacent < 2 > .

adjacent_view modélise toujours forward_range , et modélise bidirectional_range , random_access_range , ou sized_range si la vue adaptée view modélise le concept correspondant.

Table des matières

Membres de données

Membre Description
V base_ la view sous-jacente
( objet membre d'exposition uniquement* )

Fonctions membres

construit un adjacent_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

(aucun)

Classes imbriquées

le type d'itérateur
( classe membre template* à titre d'exposition uniquement )
le type sentinelle utilisé lorsque adjacent_view n'est pas un common_range
( classe membre template* à titre d'exposition uniquement )

Modèles d'assistance

template < class V, size_t N >

constexpr bool ranges:: enable_borrowed_range < adjacent_view < V, N >> =

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

Cette spécialisation de ranges::enable_borrowed_range permet à adjacent_view de satisfaire borrowed_range lorsque la vue sous-jacente la satisfait.

Notes

views :: adjacent n'accepte que les plages avant même lorsque N est 0 .

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_zip 202110L (C++23) ranges:: zip_view ,
ranges:: zip_transform_view ,
ranges::adjacent_view ,
ranges:: adjacent_transform_view

Exemple

Exécuter ce code 
#include <array>
#include <format>
#include <iostream>
#include <ranges>
#include <tuple>
int main()
{
    constexpr std::array v{1, 2, 3, 4, 5, 6};
    std::cout << "v = [1 2 3 4 5 6]\n";
    for (int i{}; std::tuple t : v | std::views::adjacent<3>)
    {
        auto [t0, t1, t2] = t;
        std::cout << std::format("e = {:<{}}[{} {} {}]\n", "", 2 * i++, t0, t1, t2);
    }
}

Sortie : 

v = [1 2 3 4 5 6]
e = [1 2 3]
e =   [2 3 4]
e =     [3 4 5]
e =       [4 5 6]

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
LWG 4098 C++23 views :: adjacent < 0 > acceptait les plages en entrée seule rejeté

Références

  • Norme C++23 (ISO/CEI 14882:2024) :
  • 26.7.25 Vue adjacente [range.adjacent]

Voir aussi

(C++23)
une view constituée des résultats de l'application d'une fonction de transformation 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)
(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)
(C++23)
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 gamme)