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 );

如果 *first 不是 可写入 到 d_first_true 或 d_first_false，则该程序非良构。

在输入范围和两个输出范围中，如果任意两个范围重叠，则行为未定义。

参数

返回值

一个从指向 d_first_true 范围末尾的迭代器和指向 d_first_false 范围末尾的迭代器构造的 std::pair 。

复杂度

恰好需要 std:: distance ( first, last ) 次对 p 的调用。

对于重载 (2) ，如果 ForwardIt 的值类型不满足 可复制构造 要求，则可能存在性能开销。

异常

带有名为 ExecutionPolicy 模板参数的重载按以下方式报告错误：

• 如果作为算法一部分调用的函数执行抛出异常，且 ExecutionPolicy 是某个 标准策略 ，则调用 std::terminate 。对于其他任何 ExecutionPolicy ，其行为由实现定义。
• 如果算法无法分配内存，则抛出 std::bad_alloc 。

可能的实现

template<class InputIt, class OutputIt1,
         class OutputIt2, class UnaryPred>
constexpr //< 自 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);
}

示例

#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

缺陷报告

下列行为变更缺陷报告被追溯应用于先前发布的 C++ 标准。

另请参阅