Namespaces
Variants

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

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Constrained algorithms
All names in this menu belong to namespace std::ranges
Non-modifying sequence operations
Modifying sequence operations
Partitioning operations
Sorting operations
Binary search operations (on sorted ranges)
Set operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Permutation operations
Fold operations
Operations on uninitialized storage
Return types
Определено в заголовочном файле <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 - проекция, применяемая к элементам

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

Объект 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 следует использовать при копировании вправо (конец целевого диапазона находится вне исходного диапазона).

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

**Примечание:** Весь код C++ внутри тегов ` 
` и `` оставлен без изменений в соответствии с инструкциями, так как содержит технические термины C++, которые не должны переводиться. HTML-разметка и атрибуты также сохранены в оригинальном виде.
копировать (1)(2) 
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 (3)(4) 
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));
// или, альтернативно,
//  std::vector<int> destination(source.size());
//  std::ranges::copy(source.begin(), source.end(), destination.begin());
// любой способ эквивалентен
//  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

Смотрите также

(C++20)
копирует диапазон элементов в обратном порядке
(объект-функция алгоритма)
(C++20)
создает копию диапазона в обратном порядке
(объект-функция алгоритма)
(C++20)
копирует указанное количество элементов в новое место
(объект-функция алгоритма)
(C++20)
присваивает диапазону элементов определенное значение
(объект-функция алгоритма)
(C++20) (C++20)
копирует диапазон элементов, пропуская те, которые удовлетворяют определенным критериям
(объект-функция алгоритма)
(C++11)
копирует диапазон элементов в новое место
(шаблон функции)