std::ranges::copy, std::ranges::copy_if, std::ranges::copy_result, std::ranges::copy_if_result
От ru.cppreference.net
| Определено в заголовке <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.Сущности, подобные функциям, описанные на этой странице, являются функциональными объектами алгоритмов (неформально известными как нийблоиды), то есть:
- При их вызове нельзя указать явные списки шаблонных аргументов.
- Ни один из них не видим для поиска, зависящего от аргументов.
- Когда любой из них находится посредством обычного неквалифицированного поиска как имя слева от оператора вызова функции, поиск, зависящий от аргументов, подавляется.
Параметры
| 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 подходит для копирования вправо (конец целевого диапазона находится вне исходного диапазона).
Возможная реализация
| copy (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));
// 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
Смотрите также
(C++20) |
копирует диапазон элементов в обратном порядке (функциональный объект алгоритма) |
(C++20) |
создаёт копию диапазона в обратном порядке (функциональный объект алгоритма) |
(C++20) |
копирует определённое количество элементов в новое местоположение (функциональный объект алгоритма) |
(C++20) |
присваивает диапазону элементов определённое значение (функциональный объект алгоритма) |
(C++20)(C++20) |
копирует диапазон элементов, пропуская те, которые удовлетворяют определённым критериям (функциональный объект алгоритма) |
(C++11) |
копирует диапазон элементов в новое местоположение (шаблон функции) |