std::partition_copy

template< class InputIt, class OutputIt1,
          class OutputIt2, class UnaryPred >
std::pair<OutputIt1, OutputIt2>
    partition_copy( InputIt first, InputIt last,
                    OutputIt1 d_first_true, OutputIt2 d_first_false,
                    UnaryPred p );

template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
          class ForwardIt3, class UnaryPred >
std::pair<ForwardIt2, ForwardIt3>
    partition_copy( ExecutionPolicy&& policy,
                    ForwardIt1 first, ForwardIt1 last,
                    ForwardIt2 d_first_true, ForwardIt3 d_first_false,
                    UnaryPred p );

Si *first n'est pas inscriptible dans d_first_true ou d_first_false, le programme est mal formé.

Parmi la vue d'entrée et les deux vues de sortie, si deux vues quelconques se chevauchent, le comportement est indéfini.

Paramètres

Valeur de retour

Une std::pair construite à partir de l'itérateur de fin de la vue d_first_true et de l'itérateur de fin de la vue d_first_false.

Complexité

Exactement std::distance(first, last) applications de p.

Pour la surcharge (2), il peut y avoir un coût de performance si le type valeur de ForwardIt n'est pas CopyConstructible.

Exceptions

La surcharge avec un paramètre template nommé ExecutionPolicy signale les erreurs comme suit :

• Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy est l'une des politiques standard, std::terminate est appelé. Pour toute autre ExecutionPolicy, le comportement est défini par l'implémentation.
• Si l'algorithme échoue à allouer de la mémoire, std::bad_alloc est levée.

Implémentation possible

template<class InputIt, class OutputIt1,
         class OutputIt2, class UnaryPred>
constexpr //< since C++20
std::pair<OutputIt1, OutputIt2>
    partition_copy(InputIt first, InputIt last,
                   OutputIt1 d_first_true, OutputIt2 d_first_false,
                   UnaryPred p)
{
    for (; first != last; ++first)
    {
        if (p(*first))
        {
            *d_first_true = *first;
            ++d_first_true;
        }
        else
        {
            *d_first_false = *first;
            ++d_first_false;
        }
    }
    
    return std::pair<OutputIt1, OutputIt2>(d_first_true, d_first_false);
}

Exemple

#include <algorithm>
#include <iostream>
#include <utility>

void print(auto rem, const auto& v)
{
    for (std::cout << rem; const auto& x : v)
        std::cout << x << ' ';
    std::cout << '\n';
}

int main()
{
    int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    int true_arr[5] = {0};
    int false_arr[5] = {0};
    
    std::partition_copy(std::begin(arr), std::end(arr),
                        std::begin(true_arr), std::begin(false_arr),
                        [](int i) { return 4 < i; });
    
    print("true_arr:  ", true_arr);
    print("false_arr: ", false_arr);
}

true_arr:  5 6 7 8 9
false_arr: 0 1 2 3 4

Rapports de défauts

Les rapports de défauts suivants modifiant le comportement ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi