std::ranges::copy, std::ranges::copy_if, std::ranges::copy_result, std::ranges::copy_if_result

Определено в заголовке `<algorithm>`
Подпись вызова
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O > requires std::indirectly_copyable<I, O> constexpr copy_result<I, O> copy( I first, S last, O result );	(1)	(с C++20)
template< ranges::input_range R, std::weakly_incrementable O > requires std::indirectly_copyable<ranges::iterator_t<R>, O> constexpr copy_result<ranges::borrowed_iterator_t<R>, O> copy( R&& r, O result );	(2)	(с C++20)
template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred > requires std::indirectly_copyable<I, O> constexpr copy_if_result<I, O> copy_if( I first, S last, O result, Pred pred, Proj proj = {} );	(3)	(с C++20)
template< ranges::input_range R, std::weakly_incrementable O, class Proj = std::identity, std::indirect_unary_predicate< std::projected<ranges::iterator_t<R>, Proj>> Pred > requires std::indirectly_copyable<ranges::iterator_t<R>, O> constexpr copy_if_result<ranges::borrowed_iterator_t<R>, O> copy_if( R&& r, O result, Pred pred, Proj proj = {} );	(4)	(с C++20)
Вспомогательные типы
template< class I, class O > using copy_result = ranges::in_out_result<I, O>;	(5)	(с C++20)
template< class I, class O > using copy_if_result = ranges::in_out_result<I, O>;	(6)	(с C++20)

Копирует элементы в диапазоне, определенном [first, last), в другой диапазон, начиная с result.

1) Копирует все элементы в диапазоне [first, last) начиная с first и продолжая до last - 1. Поведение неопределено, если result находится в диапазоне [first, last). В этом случае можно использовать ranges::copy_backward.

3) Копирует только те элементы, для которых предикат pred возвращает значение true. Относительный порядок копируемых элементов сохраняется. Поведение неопределено, если исходный и целевой диапазоны перекрываются.

2,4) То же, что (1,3), но использует r в качестве исходного диапазона, как если бы ranges::begin(r) использовался как first и ranges::end(r) как last.

Функциональные сущности, описанные на этой странице, являются niebloids, то есть:

Явные списки аргументов шаблонов не могут быть указаны при вызове любого из них.
Ни один из них не виден для поиска аргументов по зависимостям.
Когда любой из них найден с помощью обычного неопределенного поиска в качестве имени слева от оператора вызова функции, поиск аргументов по зависимостям заблокирован.

На практике они могут быть реализованы как объекты функций или с помощью специальных расширений компилятора.

Параметры

first, last	-	диапазон копируемых элементов
r	-	диапазон копируемых элементов
result	-	начало целевого диапазона.
pred	-	предикат для применения к проецированным элементам
proj	-	проекция для применения к элементам

Возвращаемое значение

A ranges::in_out_result содержащий входной итератор, равный last, и выходной итератор, следующий за последним скопированным элементом.

Сложность

1,2) Ровно last - first присваиваний.

3,4) Ровно last - first применений предиката и проекции, между 0 и last - first присваиваниями (присваивание для каждого элемента, для которого предикат возвращает true, зависит от предиката и входных данных).

Примечания

На практике реализации ranges::copy избегают множественных присваиваний и используют функции массовой копирования, такие как std::memmove, если тип значения является TriviallyCopyable, а типы итераторов удовлетворяют contiguous_iterator.

При копировании перекрывающихся диапазонов, ranges::copy подходит при копировании влево (начало целевого диапазона находится вне исходного диапазона), в то время как ranges::copy_backward подходит при копировании вправо (конец целевого диапазона находится вне исходного диапазона).

Возможная реализация

copy
struct copy_fn { template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O> requires std::indirectly_copyable<I, O> constexpr ranges::copy_result<I, O> operator()(I first, S last, O result) const { for (; first != last; ++first, (void)++result) result = first; return {std::move(first), std::move(result)}; } template<ranges::input_range R, std::weakly_incrementable O> requires std::indirectly_copyable<ranges::iterator_t<R>, O> constexpr ranges::copy_result<ranges::borrowed_iterator_t<R>, O> operator()(R&& r, O result) const { return (*this)(ranges::begin(r), ranges::end(r), std::move(result)); } }; inline constexpr copy_fn copy;
copy_if
struct copy_if_fn { template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred> requires std::indirectly_copyable<I, O> constexpr ranges::copy_if_result<I, O> operator()(I first, S last, O result, Pred pred, Proj proj = {}) const { for (; first != last; ++first) if (std::invoke(pred, std::invoke(proj, first))) { result = first; ++result; } return {std::move(first), std::move(result)}; } template<ranges::input_range R, std::weakly_incrementable O, class Proj = std::identity, std::indirect_unary_predicate< std::projected<ranges::iterator_t<R>, Proj>> Pred> requires std::indirectly_copyable<ranges::iterator_t<R>, O> constexpr ranges::copy_if_result<ranges::borrowed_iterator_t<R>, O> operator()(R&& r, O result, Pred pred, Proj proj = {}) const { return (this)(ranges::begin(r), ranges::end(r), std::move(result), std::ref(pred), std::ref(proj)); } }; inline constexpr copy_if_fn copy_if;

copy

struct copy_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O>
    requires std::indirectly_copyable<I, O>
    constexpr ranges::copy_result<I, O> operator()(I first, S last, O result) const
    {
        for (; first != last; ++first, (void)++result)
            *result = *first;
        return {std::move(first), std::move(result)};
    }
 
    template<ranges::input_range R, std::weakly_incrementable O>
    requires std::indirectly_copyable<ranges::iterator_t<R>, O>
    constexpr ranges::copy_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, O result) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(result));
    }
};
 
inline constexpr copy_fn copy;

copy_if

struct copy_if_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O,
             class Proj = std::identity,
             std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
    requires std::indirectly_copyable<I, O>
    constexpr ranges::copy_if_result<I, O>
        operator()(I first, S last, O result, Pred pred, Proj proj = {}) const
    {
        for (; first != last; ++first)
            if (std::invoke(pred, std::invoke(proj, *first)))
            {
                *result = *first;
                ++result;
            }
        return {std::move(first), std::move(result)};
    }
 
    template<ranges::input_range R, std::weakly_incrementable O,
             class Proj = std::identity,
             std::indirect_unary_predicate<
                 std::projected<ranges::iterator_t<R>, Proj>> Pred>
    requires std::indirectly_copyable<ranges::iterator_t<R>, O>
    constexpr ranges::copy_if_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, O result, Pred pred, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r),
                       std::move(result),
                       std::ref(pred), std::ref(proj));
    }
};
 
inline constexpr copy_if_fn copy_if;

Пример

Следующий код использует ranges::copy для копирования содержимого одного std::vector в другой и для отображения полученного std::vector.

#include <algorithm>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
 
int main()
{
    std::vector<int> source(10);
    std::iota(source.begin(), source.end(), 0);
 
    std::vector<int> destination;
 
    std::ranges::copy(source.begin(), source.end(),
                      std::back_inserter(destination));
// or, alternatively,
//  std::vector<int> destination(source.size());
//  std::ranges::copy(source.begin(), source.end(), destination.begin());
// either way is equivalent to
//  std::vector<int> destination = source;
 
    std::cout << "destination contains: ";
 
    std::ranges::copy(destination, std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
 
    std::cout << "odd numbers in destination are: ";
 
    std::ranges::copy_if(destination, std::ostream_iterator<int>(std::cout, " "),
                         [](int x) { return (x % 2) == 1; });
    std::cout << '\n';
}

Вывод:

destination contains: 0 1 2 3 4 5 6 7 8 9
odd numbers in destination are: 1 3 5 7 9

См. также

ranges::copy_backward (C++20)	копирует диапазон элементов в обратном порядке (niebloid)
ranges::reverse_copy (C++20)	создаёт копию диапазона, которая перевёрнута (niebloid)
ranges::copy_n (C++20)	копирует заданное количество элементов в новое местоположение (niebloid)
ranges::fill (C++20)	присваивает диапазону элементов определённое значение (niebloid)
ranges::remove_copyranges::remove_copy_if (C++20)(C++20)	копирует диапазон элементов, опуская те, которые удовлетворяют определённым критериям (niebloid)
copycopy_if (C++11)	копирует диапазон элементов в новое местоположение (шаблон функции)

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