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

Определено в заголовке `<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) Копирует элементы из входного диапазона [first, last) в два разных выходных диапазона в зависимости от значения, возвращаемого предикатом 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}, где o1 и o2 — концы выходных диапазонов соответственно после завершения копирования.

Сложность

Точно 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

См. также

ranges::partition (C++20)	разделяет диапазон элементов на две группы (niebloid)
ranges::stable_partition (C++20)	разделяет элементы на две группы, сохраняя их относительный порядок (niebloid)
ranges::copyranges::copy_if (C++20)(C++20)	копирует диапазон элементов в новое местоположение (niebloid)
ranges::remove_copyranges::remove_copy_if (C++20)(C++20)	копирует диапазон элементов, опуская те, которые удовлетворяют определённым критериям (niebloid)
partition_copy (C++11)	копирует диапазон, разделяя элементы на две группы (шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/algorithm/ranges/partition_copy