Namespaces
Variants

std::ranges:: views:: zip_transform, std::ranges:: zip_transform_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::zip_transform_view
Member functions
Deduction guides
Iterator
Member functions
Non-member functions
Sentinel
Member functions
Non-member functions
Défini dans l'en-tête <ranges>
template < std:: move_constructible F, ranges:: input_range ... Views >

requires ( ranges:: view < Views > && ... ) && ( sizeof... ( Views ) > 0 ) &&
std:: is_object_v < F > && std:: regular_invocable <
F & , ranges:: range_reference_t < Views > ... > &&
/*can-reference*/ < std:: invoke_result_t <
F & , ranges:: range_reference_t < Views > ... >>
class zip_transform_view

: public ranges:: view_interface < zip_transform_view < F, Views... >>
(1) (depuis C++23)
namespace views {

inline constexpr /*unspecified*/ zip_transform = /*unspecified*/ ;

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

requires /* voir ci-dessous */

constexpr auto zip_transform ( F && f, Rs && ... rs ) ;
(depuis C++23)
1) zip_transform_view est un adaptateur de plage qui prend un objet invocable et une ou plusieurs view s , et produit une view dont le i ème élément est le résultat de l'application de l'objet invocable aux i èmes éléments de toutes les vues.
Un type T modélise le concept d'exposition uniquement /*can-reference*/ si et seulement si T& est un type valide.
2) views::zip_transform est un objet de point de personnalisation.

Lorsqu'il est appelé avec un argument f , soit FD égal à std:: decay_t < decltype ( f ) > , si :

alors views :: zip_transform ( f ) est équivalent en expression à ( ( void ) f, auto ( views:: empty < std:: decay_t < std:: invoke_result_t < FD & >>> ) ) . Sinon, l'appel à views::zip_transform est mal formé.

Lorsqu'il est appelé avec plus d'un argument f et rs... , views :: zip_transform ( f, rs... ) est équivalent en expression à ranges :: zip_transform_view ( f, rs... ) .

zip_transform_view modélise les concepts random_access_range , bidirectional_range , forward_range , input_range , common_range , et sized_range lorsque le ranges:: zip_view < Views... > sous-jacent modélise les concepts respectifs.

Table des matières

Objets de point de personnalisation

Le nom views::zip_transform désigne un objet de point de personnalisation , qui est un objet fonction constant d'un type de classe littéral semiregular . Voir CustomizationPointObject pour plus de détails.

Fonctions membres

construit un zip_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 chaque plage sous-jacente (adaptée) satisfait sized_range
(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

Types membres

Type de membre Définition
InnerView (privé) ranges:: zip_view < Views... > .
( type de membre d'exposition uniquement* )
ziperator (privé)
zentinel (privé)

Membres de données

Objet membre Définition
zip_ (privé) Un objet vue sous-jacent de type InnerView
( objet membre d'exposition uniquement* )
fun_ (privé) Un objet invocable encapsulé de type movable-box <F>
( objet membre d'exposition uniquement* )

Classes imbriquées

le type d'itérateur
( classe membre template* d'exposition uniquement )
le type sentinelle utilisé lorsque le zip_view sous-jacent n'est pas un common_range
( classe membre template* d'exposition uniquement )

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_ranges_zip 202110L (C++23) ranges:: zip_view ,
std::ranges::zip_transform_view ,
ranges:: adjacent_view ,
ranges:: adjacent_transform_view

Exemple

Exécuter ce code 
#include <array>
#include <iostream>
#include <list>
#include <ranges>
#include <vector>
void print(auto const rem, auto const& r)
{
    std::cout << rem << '{'; 
    for (char o[]{0,' ',0}; auto const& e : r)
        std::cout << o << e, *o = ',';
    std::cout << "}\n";
}
int main()
{
    auto v1 = std::vector<float>{1, 2, 3};
    auto v2 = std::list<short>{1, 2, 3, 4};
    auto v3 = std::to_array({1, 2, 3, 4, 5});
    auto add = [](auto a, auto b, auto c) { return a + b + c; };
    auto sum = std::views::zip_transform(add, v1, v2, v3);
    print("v1:  ", v1);
    print("v2:  ", v2);
    print("v3:  ", v3);
    print("sum: ", sum);
}

Sortie : 

v1:  {1, 2, 3}
v2:  {1, 2, 3, 4}
v3:  {1, 2, 3, 4, 5}
sum: {3, 6, 9}

Voir aussi

(C++23)
une view constituée de tuples de références aux éléments correspondants des vues adaptées
(modèle de classe) (objet de point de personnalisation)
(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++20)
prend une view constituée de valeurs tuple-like et un nombre N, et produit une view du N ème élément de chaque tuple
(modèle de classe) (objet adaptateur de gamme)