命名空间
变体
操作

std::ranges::partition_copy, std::ranges::partition_copy_result

来自 cppreference.com
< cpp‎ | algorithm‎ | ranges
 
 
算法库
受约束的算法和范围上的算法 (C++20)
受约束的算法,例如 ranges::copy, ranges::sort, ...
执行策略 (C++17)
排序和相关操作
分区操作
排序操作
二进制搜索操作
(在分区范围内)
集合操作(在排序范围内)
合并操作(在排序范围内)
堆操作
最小值/最大值操作
(C++11)
(C++17)
字典序比较操作
排列操作
C 库
数值操作
对未初始化内存的操作
 
受约束的算法
此菜单中的所有名称都属于命名空间 std::ranges
非修改序列操作
修改序列操作
分区操作
partition_copy
  
排序操作
二进制搜索操作(在排序范围内)
       
       
集合操作(在排序范围内)
堆操作
最小值/最大值操作
       
       
排列操作
折叠操作
数值操作
(C++23)            
对未初始化存储的操作
返回值类型
 
定义在头文件 <algorithm>
调用签名
template< std::input_iterator I, std::sentinel_for<I> S,

          std::weakly_incrementable O1, std::weakly_incrementable O2,
          class Proj = std::identity,
          std::indirect_unary_predicate<std::projected<I, Proj>> Pred >
requires std::indirectly_copyable<I, O1> &&
         std::indirectly_copyable<I, O2>
constexpr partition_copy_result<I, O1, O2>
    partition_copy( I first, S last, O1 out_true, O2 out_false,

                    Pred pred, Proj proj = {} );
(1) (自 C++20 起)
template< ranges::input_range R,

          std::weakly_incrementable O1, std::weakly_incrementable O2,
          class Proj = std::identity,
          std::indirect_unary_predicate<std::projected<iterator_t<R>, Proj>> Pred >
requires std::indirectly_copyable<ranges::iterator_t<R>, O1> &&
         std::indirectly_copyable<ranges::iterator_t<R>, O2>
constexpr partition_copy_result<ranges::borrowed_iterator_t<R>, O1, O2>
    partition_copy( R&& r, O1 out_true, O2 out_false,

                    Pred pred, Proj proj = {} );
(2) (自 C++20 起)
辅助类型
template< class I, class O1, class O2 >
using partition_copy_result = ranges::in_out_out_result<I, O1, O2>;
(3) (自 C++20 起)
1) 将输入范围 [firstlast) 中的元素复制到两个不同的输出范围,具体取决于谓词 pred 返回的值。满足谓词 pred 的元素(在由 proj 投影后)被复制到以 out_true 开头的范围。其余元素被复制到以 out_false 开头的范围。如果输入范围与任何一个输出范围重叠,则行为未定义。
2)(1) 相同,但使用 r 作为源范围,就像使用 ranges::begin(r) 作为 first,以及 ranges::end(r) 作为 last

此页面上描述的类似函数的实体是 niebloids,即

实际上,它们可能被实现为函数对象,或使用特殊的编译器扩展。

内容

[编辑] 参数

first, last - 要从中复制元素的输入范围
r - 要从中复制元素的输入范围
out_true - 满足 pred 的元素的输出范围的开头
out_false - 不满足 pred 的元素的输出范围的开头
pred - 要应用于投影元素的谓词
proj - 要应用于元素的投影

[编辑] 返回值

{last, o1, o2},其中 o1o2 分别是输出范围的末尾,在复制完成后。

[编辑] 复杂度

正好 ranges::distance(first, last) 次应用相应的谓词 comp 和任何投影 proj

[编辑] 可能的实现

struct partition_copy_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S,
             std::weakly_incrementable O1, std::weakly_incrementable O2,
             class Proj = std::identity, std::indirect_unary_predicate<
             std::projected<I, Proj>> Pred>
    requires std::indirectly_copyable<I, O1> && std::indirectly_copyable<I, O2>
    constexpr ranges::partition_copy_result<I, O1, O2>
        operator()(I first, S last, O1 out_true, O2 out_false,
                   Pred pred, Proj proj = {}) const
    {
        for (; first != last; ++first)
            if (!!std::invoke(pred, std::invoke(proj, *first)))
                *out_true = *first, ++out_true;
            else
                *out_false = *first, ++out_false;
        return {std::move(first), std::move(out_true), std::move(out_false)};
    }
 
    template<ranges::input_range R,
             std::weakly_incrementable O1, std::weakly_incrementable O2,
             class Proj = std::identity,
             std::indirect_unary_predicate<std::projected<iterator_t<R>, Proj>> Pred>
    requires std::indirectly_copyable<ranges::iterator_t<R>, O1> &&
             std::indirectly_copyable<ranges::iterator_t<R>, O2>
    constexpr ranges::partition_copy_result<ranges::borrowed_iterator_t<R>, O1, O2>
        operator()(R&& r, O1 out_true, O2 out_false, Pred pred, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(out_true),
                       std::move(out_false), std::move(pred), std::move(proj));
    }
};
 
inline constexpr partition_copy_fn partition_copy {};

[编辑] 示例

#include <algorithm>
#include <cctype>
#include <iostream>
#include <iterator>
#include <vector>
 
int main()
{
    const auto in = {'N', '3', 'U', 'M', '1', 'B', '4', 'E', '1', '5', 'R', '9'};
 
    std::vector<int> o1(size(in)), o2(size(in));
 
    auto pred = [](char c) { return std::isalpha(c); };
 
    auto ret = std::ranges::partition_copy(in, o1.begin(), o2.begin(), pred);
 
    std::ostream_iterator<char> cout {std::cout, " "};
    std::cout << "in = ";
    std::ranges::copy(in, cout);
    std::cout << "\no1 = ";
    std::copy(o1.begin(), ret.out1, cout);
    std::cout << "\no2 = ";
    std::copy(o2.begin(), ret.out2, cout);
    std::cout << '\n';
}

输出

in = N 3 U M 1 B 4 E 1 5 R 9
o1 = N U M B E R
o2 = 3 1 4 1 5 9

[编辑] 参见

将一个元素范围分成两组
(niebloid)[编辑]
将元素分成两组,同时保留它们的相对顺序
(niebloid)[编辑]
将一个元素范围复制到一个新位置
(niebloid)[编辑]
复制一个元素范围,省略满足特定条件的元素
(niebloid)[编辑]
复制一个范围,将元素分成两组
(函数模板) [编辑]