Namespaces
Variants

std::ranges:: views:: adjacent_transform, std::ranges:: adjacent_transform_view, std::ranges:: views:: pairwise_transform

From cppreference.net
C++
Ranges library
Range adaptors
(C++23) (C++23)
(C++23)
adjacent_transform_view views::adjacent_transform
(C++23) (C++23)
views::pairwise_transform
(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_transform_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:: move_constructible F, std:: size_t N >

requires ranges:: view < V > && ( N > 0 ) && std:: is_object_v < F > &&
std:: regular_invocable < F & ,
/*REPEAT*/ ( ranges:: range_reference_t < V > , N ) ... > &&
/*can-reference*/ < std:: invoke_result_t < F & ,
/*REPEAT*/ ( ranges:: range_reference_t < V > , N ) ... >>
class adjacent_transform_view

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

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

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

inline constexpr auto pairwise_transform = adjacent_transform < 2 > ;

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

requires /* voir ci-dessous */

constexpr ranges:: view auto adjacent_transform < N > ( R && r, F && fun ) ;
(depuis C++23)
template < class F >
constexpr /*adaptateur de gamme de fermeture*/ adjacent_transform < N > ( F && fun ) ;
(depuis C++23)
1) adjacent_transform_view est un adaptateur de plage qui prend une view et un objet invocable fun , et produit une view dont le i ème élément est une valeur résultant de l'application de fun à chaque élément dans [ i , i + N ) de la vue originale. F a toujours une arité N .
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_transform < N > désigne un RangeAdaptorObject . Étant données les sous-expressions e et f , et une expression constante N , l'expression views :: adjacent_transform < N > ( e, f ) est équivalente en expression à :
3) Le nom views :: pairwise_transform désigne un RangeAdaptorObject qui se comporte exactement comme views :: adjacent_transform < 2 > . En particulier, l'arité de F est également 2 et fun est un objet invocable binaire.

adjacent_transform_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

Fonctions membres

construit un adjacent_transform_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 une 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> )

Types imbriqués

Type Définition
InnerView (privé) ranges:: adjacent_view < V, N >
( type membre d'exposition uniquement* )
inner_iterator (privé)
inner_sentinel (privé)

Membres de données

Membre Description
/*movable-box*/ < F > fun_ (privé) l'objet invocable de transformation
( objet membre d'exposition uniquement* )
ranges:: adjacent_view < V,N > inner_ (privé) la vue stockée
( objet membre d'exposition uniquement* )

Classes imbriquées

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

Notes

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

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 <iostream>
#include <ranges>
int main()
{
    constexpr static std::array data{1, 2, 3, 4, 5, 6};
    constexpr int window{3};
    auto Fun = [](auto... ints) { return (... + ints); };
    // Alternativement, Fun pourrait être n'importe quel objet appelable ternaire (si window == 3), par exemple :
    // auto Fun = [](int x, int y, int z) { return x + y + z; };
    constexpr auto view = data | std::views::adjacent_transform<window>(Fun);
    static_assert(
        view.size() == (data.size() - window + 1)
        && std::array{6, 9, 12, 15}
        == std::array{view[0], view[1], view[2], view[3]}
        && view[0] == Fun(data[0], data[1], data[2])
        && view[1] == Fun(data[1], data[2], data[3])
        && view[2] == Fun(data[2], data[3], data[4])
        && view[3] == Fun(data[3], data[4], data[5])
    );
    for (int x : view)
        std::cout << x << ' ';
    std::cout << '\n';
}

Sortie : 

6 9 12 15

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 Appliqué à Comportement publié Comportement corrigé
LWG 4098 C++23 views :: adjacent_transform < 0 > acceptait les plages en entrée uniquement rejeté

Références

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

Voir aussi

(C++23)
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++20)
une view d'une séquence qui applique une fonction de transformation à chaque élément
(modèle de classe) (objet adaptateur de gamme)
(C++23)
une view constituée des résultats de l'application d'une fonction de transformation aux éléments correspondants des vues adaptées
(modèle de classe) (objet de point de personnalisation)
(C++20)
applique une fonction à une gamme d'éléments
(objet fonction algorithme)