std::ranges::copy_backward, std::ranges::copy_backward_result

Определено в заголовке `<algorithm>`
Подпись вызова
template< std::bidirectional_iterator I1, std::sentinel_for<I1> S1, std::bidirectional_iterator I2 > requires std::indirectly_copyable<I1, I2> constexpr copy_backward_result<I1, I2> copy_backward( I1 first, S1 last, I2 result );	(1)	(с C++20)
template< ranges::bidirectional_range R, std::bidirectional_iterator I > requires std::indirectly_copyable<ranges::iterator_t<R>, I> constexpr copy_backward_result<ranges::borrowed_iterator_t<R>, I> copy_backward( R&& r, I result );	(2)	(с C++20)
Вспомогательные типы
template< class I1, class I2 > using copy_backward_result = ranges::in_out_result<I1, I2>;	(3)	(с C++20)

1) Копирует элементы из диапазона, определенного [first, last), в другой диапазон [result - N, result), где N = ranges::distance(first, last). Элементы копируются в обратном порядке (сначала копируется последний элемент), но их относительный порядок сохраняется. Поведение неопределено, если result находится внутри (first, last]. В таком случае вместо него можно использовать std::ranges::copy.

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

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

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

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

Параметры

first	-	начало диапазона элементов, которые нужно скопировать
last	-	конец диапазона элементов, которые нужно скопировать
r	-	диапазон элементов, которые нужно скопировать
result	-	конец целевого диапазона

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

{last, result - N}

Сложность

Ровно N присваиваний.

Примечания

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

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

struct copy_backward_fn
{
    template<std::bidirectional_iterator I1, std::sentinel_for<I1> S1,
             std::bidirectional_iterator I2>
    requires std::indirectly_copyable<I1, I2>
    constexpr ranges::copy_backward_result<I1, I2>
        operator()(I1 first, S1 last, I2 result) const
    {
        I1 last1 {ranges::next(first, std::move(last))};
        for (I1 i {last1}; i != first;)
            *--result = *--i;
        return {std::move(last1), std::move(result)};
    }
 
    template<ranges::bidirectional_range R, std::bidirectional_iterator I>
    requires std::indirectly_copyable<ranges::iterator_t<R>, I>
    constexpr ranges::copy_backward_result<ranges::borrowed_iterator_t<R>, I>
        operator()(R&& r, I result) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(result));
    }
};
 
inline constexpr copy_backward_fn copy_backward{};

Пример

#include <algorithm>
#include <iostream>
#include <ranges>
#include <string_view>
#include <vector>
 
void print(std::string_view rem, std::ranges::forward_range auto const& r)
{
    for (std::cout << rem << ": "; auto const& elem : r)
        std::cout << elem << ' ';
    std::cout << '\n';
}
 
int main()
{
    const auto src = {1, 2, 3, 4};
    print("src", src);
 
    std::vector<int> dst(src.size() + 2);
    std::ranges::copy_backward(src, dst.end());
    print("dst", dst);
 
    std::ranges::fill(dst, 0);
    const auto [in, out] =
        std::ranges::copy_backward(src.begin(), src.end() - 2, dst.end());
    print("dst", dst);
 
    std::cout
        << "(in - src.begin) == " << std::distance(src.begin(), in) << '\n'
        << "(out - dst.begin) == " << std::distance(dst.begin(), out) << '\n';
}

Вывод:

src: 1 2 3 4
dst: 0 0 1 2 3 4
dst: 0 0 0 0 1 2
(in - src.begin) == 2
(out - dst.begin) == 4

См. также

ranges::copyranges::copy_if (C++20)(C++20)	копирует диапазон элементов в новое местоположение (неблокирующий)
ranges::copy_n (C++20)	копирует определённое количество элементов в новое местоположение (неблокирующий)
ranges::remove_copyranges::remove_copy_if (C++20)(C++20)	копирует диапазон элементов, опуская те, которые удовлетворяют определённым критериям (неблокирующий)
ranges::replace_copyranges::replace_copy_if (C++20)(C++20)	копирует диапазон, заменяя элементы, удовлетворяющие определённым критериям, другим значением (неблокирующий)
ranges::reverse_copy (C++20)	создаёт копию диапазона, которая перевернута (неблокирующий)
ranges::rotate_copy (C++20)	копирует и вращает диапазон элементов (неблокирующий)
ranges::unique_copy (C++20)	создаёт копию диапазона элементов, не содержащую последовательных дубликатов (неблокирующий)
ranges::move (C++20)	перемещает диапазон элементов в новое местоположение (неблокирующий)
ranges::move_backward (C++20)	перемещает диапазон элементов в новое местоположение в обратном порядке (неблокирующий)
copy_backward	копирует диапазон элементов в обратном порядке (шаблон функции)

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