std::partition_copy() algorithm

since C++20

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

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

since C++17

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

• (1) Copies the elements from the range [first; last) to two different ranges depending on the value returned by the predicate p.

  The elements that satisfy the predicate p are copied to the range beginning at d_first_true. The rest of the elements are copied to the range beginning at d_first_false.

  Undefined Behaviour

  The behavior is undefined

  if the input range overlaps either of the output ranges.

• (2) Same as (1), but executed according to policy.

  Overload Resolution

  These overloads participate in overload resolution only if std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>  (until C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>  (since C++20) is true.

Parameters

first last	The range of elements to copy from.
d_first_true	The beginning of the output range for the elements that satisfy p
d_first_false	The beginning of the output range for the elements that don't satisfy p
policy	The execution policy to use. See execution policy for details.
p	Unary predicate which returns true for the required element. The expression p(v) must be convertible to bool for every argument v of type (possibly const) VT, where VT is the value type of InputIt, regardless of value category, and must not modify v. Thus, a parameter type of VT& is not allowed , nor is VT unless for VT a move is equivalent to a copy. (since C++11).

Type requirements

InputIt	LegacyInputIterator
Dereferenced InputIt	CopyAssignable
OutputIt1 OutputIt2	LegacyOutputIterator
ForwardIt1 ForwardIt2 ForwardIt3	LegacyForwardIterator
UnaryPredicate	Predicate

ForwardIt1::value_type must be:

• CopyAssignable
• Writable to ForwardIt2 and ForwardIt3
• Convertible to UnaryPredicate's argument type

Return value

A std::pair constructed from the iterator to the end of the d_first_true range and the iterator to the end of the d_first_false range.

Complexity

Exactly std::distance(first, last) applications of p.

For the overload with an ExecutionPolicy, there may be a performance cost if ForwardIt's value type is not CopyConstructible.

Exceptions

The overloads with a template parameter named ExecutionPolicy report errors as follows:

• If execution of a function invoked as part of the algorithm throws an exception and ExecutionPolicy is one of the standard policies, std::terminate is called. For any other ExecutionPolicy, the behavior is implementation-defined.
• If the algorithm fails to allocate memory, std::bad_alloc is thrown.

Possible implementation

partition_copy (1)

template<class InputIt, class OutputIt1,
         class OutputIt2, class UnaryPredicate>
std::pair<OutputIt1, OutputIt2>
    partition_copy(InputIt first, InputIt last,
                   OutputIt1 d_first_true, OutputIt2 d_first_false,
                   UnaryPredicate 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);
}

Examples

Main.cpp

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

void print(auto rem, auto const& v)
{
    for (std::cout << rem; auto const& 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);
}

Output

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