std::ranges::reverse_copy() 算法

自 C++20 起

简化

// (1)
constexpr reverse_copy_result<I, O>
    reverse_copy( I first, S last, O result );

// (2)
constexpr reverse_copy_result<ranges::borrowed_iterator_t<R>, O>
    reverse_copy( R&& r, O result );

参数类型是泛型的，并具有以下约束：

• I - std::bidirectional_iterator
• S - std::sentinel_for<I>
• R - ranges::bidirectional_range
• O - std::weakly_incrementable

此外，每个重载都有以下约束

• (1) - std::indirectly_copyable<I, O>
• (2) - std::indirectly_copyable<ranges::iterator_t<R>, O>

详细

// (1)
template<
  std::bidirectional_iterator I,
  std::sentinel_for<I> S,
  std::weakly_incrementable O
>
  requires std::indirectly_copyable<I, O>
constexpr reverse_copy_result<I, O>
    reverse_copy( I first, S last, O result );

// (2)
template<
  ranges::bidirectional_range R,
  std::weakly_incrementable O
>
  requires std::indirectly_copyable<ranges::iterator_t<R>, O>
constexpr reverse_copy_result<ranges::borrowed_iterator_t<R>, O>
    reverse_copy( R&& r, O result );

辅助类型定义如下：

template< class I, class O >
using reverse_copy_result = ranges::in_out_result<I, O>;

• (1) 给定 N 为 ranges::distance(first, last)

  将源范围 [first; last) 中的元素复制到目标范围 [result; result + N) 中，使得新范围中的元素按逆序排列。

  其行为如同对 [0; N) 中的每个整数 i 执行一次赋值 *(result + N - 1 - i) = *(first + i)。

• (2) 与 (1) 相同，但使用 r 作为源范围，如同使用 ranges::begin(r) 作为 first 和 ranges::end(r) 作为 last。

未定义行为

行为未定义

如果源范围和目标范围重叠。

本页描述的函数类实体是niebloids。

参数

first last	要复制的元素范围。
r	要复制的元素范围。
result	目标范围的开头。

返回值

类型为 ranges::reverse_copy_result 的值，按如下方式初始化

{
  last,
  result + N
}

其中 N 是 ranges::distance(first, last)。

复杂度

恰好 ranges::distance(first, last) 次赋值。

异常

(无)

可能的实现

reverse_copy(1)

struct reverse_copy_fn
{
    template<std::bidirectional_iterator I, std::sentinel_for<I> S,
             std::weakly_incrementable O>
    requires std::indirectly_copyable<I, O>
    constexpr ranges::reverse_copy_result<I, O>
        operator()(I first, S last, O result) const
    {
        auto ret = ranges::next(first, last);
        for (; last != first; *result = *--last, ++result);
        return {std::move(ret), std::move(result)};
    }

    template<ranges::bidirectional_range R, std::weakly_incrementable O>
    requires std::indirectly_copyable<ranges::iterator_t<R>, O>
    constexpr ranges::reverse_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 reverse_copy_fn reverse_copy {};

备注

当两个迭代器类型都满足 LegacyContiguousIterator 并具有相同的值类型，并且值类型为 TriviallyCopyable 时，实现（例如 MSVC STL）可能会启用向量化。

示例

Main.cpp

#include <algorithm>
#include <iostream>
#include <string>

int main()
{
    std::string x {"12345"}, y(x.size(), ' ');
    std::cout << x << " → ";
    std::ranges::reverse_copy(x.begin(), x.end(), y.begin());
    std::cout << y << " → ";
    std::ranges::reverse_copy(y, x.begin());
    std::cout << x << '\n';
}

输出

12345 → 54321 → 12345