Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::transform_reduce — transformation et réduction

std::transform_reduce, dans <numeric>, transforme les éléments d’une plage ou les paires correspondantes de deux plages, puis combine les résultats avec init. L’ordre et le regroupement de la réduction ne sont pas spécifiés.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

std::transform_reduce(first, last, init, reduce_op, transform_op)
std::transform_reduce(first1, last1, first2, init)
std::transform_reduce(first1, last1, first2, init, reduce_op, transform_op)
// Each form also has an overload with an execution policy as its first argument.

std::transform_reduce, dans <numeric>, renvoie une valeur unique de type T, déduit de init. La forme à une plage applique transform_op à chaque élément de [first, last), tandis que reduce_op combine les résultats et init. init n’est pas transformé ; une plage vide renvoie init.

La forme à deux plages transforme les paires d’éléments correspondantes. La deuxième plage doit contenir au moins autant d’éléments que la première, car sa fin n’est pas passée à la fonction. La surcharge sans opérations explicites utilise std::plus<> et std::multiplies<> pour calculer un produit scalaire auquel init est ajouté.

La réduction peut réordonner et regrouper les valeurs, même sans politique d’exécution : ce n’est pas un pliage à gauche comme std::accumulate. Pour obtenir un résultat stable, utilisez une opération associative et commutative et évitez les dépassements de capacité. L’addition en virgule flottante peut produire des résultats différents à cause des arrondis. Les opérations ne doivent ni modifier les éléments d’entrée ni invalider les plages. reduce_op doit accepter chaque paire de valeurs provenant de init et des résultats de transformation, avec un résultat convertible en T.

Le nombre d’applications des deux opérations est linéaire par rapport à la longueur de la plage. Les surcharges sans politique acceptent les itérateurs d’entrée ; celles avec politique d’exécution exigent des itérateurs forward. Une politique ne garantit ni accélération ni exécution réellement parallèle.

Exemples

#include <array>
#include <iostream>
#include <numeric>

int main() {
    const std::array<int, 3> a{1, 2, 3};
    const std::array<int, 3> b{4, 5, 6};

    const int result = std::transform_reduce(
        a.begin(), a.end(), b.begin(), 0);

    std::cout << result << '\n';
}

Résultat

32

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources