std::ranges::views::zip_transform, std::ranges::zip_transform_view
Depuis fr.cppreference.net
| 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 /* see below */
constexpr auto zip_transform( F&& f, Rs&&... rs );
|
(depuis C++23) | |
1)
Un type
zip_transform_view est un adaptateur de plage qui prend un objet invocable et une ou plusieurs vues, et produit une vue 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 point de personnalisation.
Lors de l'appel avec un argument f, soit FD égal à std::decay_t<decltype(f)>, si :
FDmodélise copy_constructible,FD&modélise regular_invocable, etstd::invoke_result_t<FD&>est un type objet,
alors views::zip_transform(f) est équivalent à l'expression à ((void)f, auto(views::empty<std::decay_t<std::invoke_result_t<FD&>>>)). Sinon, l'appel à views::zip_transform est mal formé.
f et rs..., views::zip_transform(f, rs...) est équivalent à l'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 la ranges::zip_view<Views...> sous-jacente modélise les concepts respectifs.
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ée de ranges::view_interface | |
| indique 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>)
|
| indique 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 dans 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 dans 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 nème élément dans 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
Types membres
| Type | Définition |
InnerView (privé)
|
ranges::zip_view<Views...>.(type membre d'exposition uniquement*) |
ziperator (privé)
|
|
zentinel (privé)
|
|
Membres de données
| Membre | Description |
InnerView zip_ (privé)
|
un objet de vue sous-jacent (objet membre d'exposition uniquement*) |
boîte mobile<F> fun_ (privé)
|
un objet invocable encapsulé (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 vue constituée de tuples de références aux éléments correspondants des vues adaptées (modèle de classe) (objet point de personnalisation) |
| une vue d'une séquence qui applique une fonction de transformation à chaque élément (modèle de classe) (objet adaptateur de plage) | |
| prend une vue constituée de valeurs de type tuple-like et un nombre N, et produit une vue du N-ième élément de chaque tuple (modèle de classe) (objet adaptateur de plage) |