std::ranges::transform, std::ranges::unary_transform_result, std::ranges::binary_transform_result

Défini dans l'en-tête `<algorithm>`
Signature d'appel
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, std::copy_constructible F, class Proj = std::identity > requires std::indirectly_writable<O, std::indirect_result_t<F&, std::projected<I, Proj>>> constexpr unary_transform_result<I, O> transform( I first1, S last1, O result, F op, Proj proj = {} );	(1)	(depuis C++20)
template< ranges::input_range R, std::weakly_incrementable O, std::copy_constructible F, class Proj = std::identity > requires std::indirectly_writable<O, std::indirect_result_t<F&, std::projected<ranges::iterator_t<R>, Proj>>> constexpr unary_transform_result<ranges::borrowed_iterator_t<R>, O> transform( R&& r, O result, F op, Proj proj = {} );	(2)	(depuis C++20)
template< std::input_iterator I1, std::sentinel_for<I1> S1, std::input_iterator I2, std::sentinel_for<I2> S2, std::weakly_incrementable O, std::copy_constructible F, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_writable<O, std::indirect_result_t<F&, std::projected<I1, Proj1>, std::projected<I2, Proj2>>> constexpr binary_transform_result<I1, I2, O> transform( I1 first1, S1 last1, I2 first2, S2 last2, O result, F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {} );	(3)	(depuis C++20)
template< ranges::input_range R1, ranges::input_range R2, std::weakly_incrementable O, std::copy_constructible F, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_writable<O, std::indirect_result_t<F&, std::projected<ranges::iterator_t<R1>, Proj1>, std::projected<ranges::iterator_t<R2>, Proj2>>> constexpr binary_transform_result<ranges::borrowed_iterator_t<R1>, ranges::borrowed_iterator_t<R2>, O> transform( R1&& r1, R2&& r2, O result, F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {} );	(4)	(depuis C++20)
Types d'assistance
template< class I, class O > using unary_transform_result = ranges::in_out_result<I, O>;	(5)	(depuis C++20)
template< class I1, class I2, class O > using binary_transform_result = ranges::in_in_out_result<I1, I2, O>;	(6)	(depuis C++20)

Applique la fonction donnée à une plage et stocke le résultat dans une autre plage, en commençant à result.

1) L'opération unaire op est appliquée à la plage définie par [first1, last1) (après projection avec la projection proj).

2) Identique à (1), mais utilise r comme plage source, comme si on utilisait ranges::begin(r) comme first et ranges::end(r) comme last.

3) L'opération binaire binary_op est appliquée à des paires d'éléments provenant de deux plages : l'une définie par [first1, last1) et l'autre définie par [first2, last2) (après projection respective avec les projections proj1 et proj2).

4) Identique à (3), mais utilise r1 comme première plage source, comme si on utilisait ranges::begin(r1) comme first1 et ranges::end(r1) comme last1, et de même pour r2.

Les entités de type fonction décrites sur cette page sont des objets fonctions d'algorithmes (informellement appelés niebloïdes), c'est-à-dire :

Les listes explicites d'arguments de template ne peuvent pas être spécifiées lors de l'appel de l'une d'entre elles.
Aucune d'entre elles n'est visible par la recherche dépendante des arguments.
Lorsque l'une d'entre elles est trouvée par la recherche normale non qualifiée comme le nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.

Paramètres

first1, last1	-	la paire itérateur-sentinelle définissant la première plage d'éléments à transformer
r, r1	-	la première plage d'éléments à transformer
first2, last2	-	la paire itérateur-sentinelle définissant la seconde plage d'éléments à transformer
r2	-	la seconde plage d'éléments à transformer
result	-	le début de la plage de destination, peut être égal à first1 ou first2
op, binary_op	-	opération à appliquer aux éléments projetés
proj1	-	projection à appliquer aux éléments de la première plage
proj2	-	projection à appliquer aux éléments de la seconde plage

Valeur de retour

1,2) Un


        unary_transform_result

contient un itérateur d'entrée égal à last et un itérateur de sortie vers l'élément suivant le dernier élément transformé.

3,4) Un


        binary_transform_result

contient des itérateurs d'entrée vers les derniers éléments transformés des plages

first1

last1

et

first2

last2

respectivement comme

in1

et

in2

, et l'itérateur de sortie vers l'élément suivant le dernier élément transformé comme

out

.

Complexité

1,2) Exactement ranges:: distance ( first1, last1 ) applications de op et proj .

3,4) Exactement ranges:: min ( ranges:: distance ( first1, last1 ) , ranges:: distance ( first2, last2 ) ) applications de binary_op et des projections.

Implémentation possible

struct transform_fn
{
    // Première version
    template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O,
             std::copy_constructible F, class Proj = std::identity>
    requires std::indirectly_writable<O, std::indirect_result_t<F&,
                                                                std::projected<I, Proj>>>
    constexpr ranges::unary_transform_result<I, O>
        operator()(I first1, S last1, O result, F op, Proj proj = {}) const
    {
        for (; first1 != last1; ++first1, (void)++result)
            *result = std::invoke(op, std::invoke(proj, *first1));
        return {std::move(first1), std::move(result)};
    }
    // Deuxième version
    template<ranges::input_range R, std::weakly_incrementable O,
             std::copy_constructible F, class Proj = std::identity>
    requires std::indirectly_writable<O,
                 std::indirect_result_t<F&, std::projected<ranges::iterator_t<R>, Proj>>>
    constexpr ranges::unary_transform_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, O result, F op, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(result),
                       std::move(op), std::move(proj));
    }
    // Troisième version
    template<std::input_iterator I1, std::sentinel_for<I1> S1,
             std::input_iterator I2, std::sentinel_for<I2> S2,
             std::weakly_incrementable O,
             std::copy_constructible F,
             class Proj1 = std::identity, class Proj2 = std::identity>
    requires std::indirectly_writable<O,
                 std::indirect_result_t<F&,
                                        std::projected<I1, Proj1>,
                                        std::projected<I2, Proj2>>>
    constexpr ranges::binary_transform_result<I1, I2, O>
        operator()(I1 first1, S1 last1, I2 first2, S2 last2, O result,
                   F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        for (; first1 != last1 && first2 != last2;
             ++first1, (void)++first2, (void)++result)
            *result = std::invoke(binary_op,
                                  std::invoke(proj1, *first1),
                                  std::invoke(proj2, *first2));
        return {std::move(first1), std::move(first2), std::move(result)};
    }
    // Quatrième version
    template<ranges::input_range R1, ranges::input_range R2,
             std::weakly_incrementable O, std::copy_constructible F,
             class Proj1 = std::identity, class Proj2 = std::identity>
    requires std::indirectly_writable<O,
                 std::indirect_result_t<F&,
                     std::projected<ranges::iterator_t<R1>, Proj1>,
                     std::projected<ranges::iterator_t<R2>, Proj2>>>
    constexpr ranges::binary_transform_result<ranges::borrowed_iterator_t<R1>,
                                              ranges::borrowed_iterator_t<R2>, O>
        operator()(R1&& r1, R2&& r2, O result,
                   F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        return (*this)(ranges::begin(r1), ranges::end(r1),
                       ranges::begin(r2), ranges::end(r2),
                       std::move(result), std::move(binary_op),
                       std::move(proj1), std::move(proj2));
    }
};
inline constexpr transform_fn transform;

Notes

ranges::transform ne garantit pas l'application dans l'ordre de op ou binary_op . Pour appliquer une fonction à une séquence dans l'ordre ou pour appliquer une fonction qui modifie les éléments d'une séquence, utilisez ranges::for_each .

Exemple

Le code suivant utilise ranges::transform pour convertir une chaîne en place en majuscules en utilisant la fonction std::toupper puis transforme chaque char en sa valeur ordinale. Ensuite, ranges::transform avec une projection est utilisé pour transformer les éléments de std:: vector < Foo > en chars pour remplir une std::string .

Exécuter ce code

#include <algorithm>
#include <cctype>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
int main()
{
    std::string s{"hello"};
    auto op = [](unsigned char c) -> unsigned char { return std::toupper(c); };
    namespace ranges = std::ranges;
    // uppercase the string in-place
    ranges::transform(s.begin(), s.end(), s.begin(), op );
    std::vector<std::size_t> ordinals;
    // convert each char to size_t
    ranges::transform(s, std::back_inserter(ordinals),
                      [](unsigned char c) -> std::size_t { return c; });
    std::cout << s << ':';
    for (auto ord : ordinals)
        std::cout << ' ' << ord;
    // double each ordinal
    ranges::transform(ordinals, ordinals, ordinals.begin(), std::plus{});
    std::cout << '\n';
    for (auto ord : ordinals)
        std::cout << ord << ' ';
    std::cout << '\n';
    struct Foo { char bar; };
    const std::vector<Foo> f = {{'h'},{'e'},{'l'},{'l'},{'o'}};
    std::string result;
    // project, then uppercase
    ranges::transform(f, std::back_inserter(result), op, &Foo::bar);
    std::cout << result << '\n';
}

Sortie :

HELLO: 72 69 76 76 79
144 138 152 152 158
HELLO

Voir aussi

ranges::for_each (C++20)	applique un objet fonction unaire aux éléments d'une plage (objet fonction algorithme)
ranges::transform_view views::transform (C++20)	une `view` d'une séquence qui applique une fonction de transformation à chaque élément (modèle de classe) (objet adaptateur de plage)
transform	applique une fonction à une plage d'éléments, stockant les résultats dans une plage de destination (modèle de fonction)

Support du compilateur
Autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque Ranges (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque de système de fichiers (C++17)
Bibliothèque de support de concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants