命名空间
变体
操作

std::ranges::rotate_copy, std::ranges::rotate_copy_result

来自 cppreference.cn
< cpp‎ | 算法‎ | 范围
 
 
算法库
有约束算法与针对范围的算法 (C++20)
有约束的算法,例如 ranges::copyranges::sort 等……
执行策略 (C++17)
排序及相关操作
划分操作
排序操作
二分搜索操作
(于已划分范围上)
集合操作(于已排序范围上)
归并操作(于已排序范围上)
堆操作
最小/最大值操作
(C++11)
(C++17)
字典序比较操作
排列操作
C 库
数值操作
未初始化内存上的操作
 
受约束算法
此菜单中的所有名称均属于命名空间 std::ranges
非修改序列操作
修改序列操作
划分操作
排序操作
二分查找操作(在已排序的范围内)
       
       
集合操作(于已排序范围上)
堆操作
最小/最大值操作
       
       
排列操作
折叠操作
数值操作
(C++23)            
对未初始化存储的操作
返回类型
 
定义于头文件 <algorithm>
调用签名 (Call signature)
template< std::forward_iterator I, std::sentinel_for<I> S,

          std::weakly_incrementable O >
requires std::indirectly_copyable<I, O>
constexpr rotate_copy_result<I, O>

    rotate_copy( I first, I middle, S last, O result );
(1) (C++20 起)
template< ranges::forward_range R, std::weakly_incrementable O >

requires std::indirectly_copyable<ranges::iterator_t<R>, O>
constexpr rotate_copy_result<ranges::borrowed_iterator_t<R>, O>

    rotate_copy( R&& r, ranges::iterator_t<R> middle, O result );
(2) (C++20 起)
辅助类型
template< class I, class O >
using rotate_copy_result = in_out_result<I, O>;
(3) (C++20 起)

[firstlast)左旋转复制到 result

1) 复制源范围 [firstlast) 中的元素,使得在目标范围中,[firstmiddle) 中的元素放置在 [middlelast) 中的元素之后,同时保持两个范围中元素的顺序。
如果 [firstmiddle)[middlelast) 不是有效范围,或源范围和目标范围重叠,则行为是未定义的。
2)(1),但使用 r 作为源范围,如同使用 ranges::begin(r) 作为 firstranges::end(r) 作为 last

本页描述的类函数实体是 算法函数对象(非正式地称为 niebloids),即

目录

[编辑] 参数

first, last - 定义要复制的源元素范围的迭代器-哨兵对
r - 要从中复制元素的源范围
middle - 指向应出现在目标范围开头的元素的迭代器
result - 目标范围的开头

[编辑] 返回值

{last, result + N},其中 N = ranges::distance(first, last)

[编辑] 复杂度

线性:精确 N 次赋值。

[编辑] 注意

如果值类型为可平凡复制 (TriviallyCopyable) 并且迭代器类型满足 contiguous_iterator,则 ranges::rotate_copy 的实现通常会通过使用“批量复制”函数(例如 std::memmove)来避免多次赋值。

[编辑] 可能的实现

另见 libstdc++MSVC STL 中的实现。

struct rotate_copy_fn
{
    template<std::forward_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O>
    requires std::indirectly_copyable<I, O>
    constexpr ranges::rotate_copy_result<I, O>
        operator()(I first, I middle, S last, O result) const
    {
        auto c1 {ranges::copy(middle, std::move(last), std::move(result))};
        auto c2 {ranges::copy(std::move(first), std::move(middle), std::move(c1.out))};
        return {std::move(c1.in), std::move(c2.out)};
    }
 
    template<ranges::forward_range R, std::weakly_incrementable O>
    requires std::indirectly_copyable<ranges::iterator_t<R>, O>
    constexpr ranges::rotate_copy_result<ranges::borrowed_iterator_t<R>, O>
        operator()(R&& r, ranges::iterator_t<R> middle, O result) const
    {
        return (*this)(ranges::begin(r), std::move(middle),
                       ranges::end(r), std::move(result));
    }
};
 
inline constexpr rotate_copy_fn rotate_copy {};

[编辑] 示例

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
 
int main()
{
    std::vector<int> src {1, 2, 3, 4, 5};
    std::vector<int> dest(src.size());
    auto pivot = std::ranges::find(src, 3);
 
    std::ranges::rotate_copy(src, pivot, dest.begin());
    for (int i : dest)
        std::cout << i << ' ';
    std::cout << '\n';
 
    // copy the rotation result directly to the std::cout
    pivot = std::ranges::find(dest, 1);
    std::ranges::rotate_copy(dest, pivot, std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
}

输出

3 4 5 1 2
1 2 3 4 5

[编辑] 参阅

旋转一个范围中元素的顺序
(算法函数对象)[编辑]
将一个范围的元素复制到一个新位置
(算法函数对象)[编辑]
复制并旋转一个范围的元素
(函数模板) [编辑]