Namespaces
Variants

    std::shift_left, std::shift_right

    来自 zh.cppreference.net
     
    C++
     
    算法库
    受约束算法和范围算法 (C++20)
    受约束算法，例如 ranges::copy, ranges::sort, ...
    排序和相关操作
    划分操作
    (C++11)    
    (C++11)

    排序操作
    二分搜索操作
    (在已划分范围上)
    集合操作（在已排序范围上）
    归并操作（在已排序范围上）
    堆操作
    最小/最大操作
    (C++11)
    (C++17)
    字典序比较操作
    (C++20)
    排列操作


     
    定义于头文件 <algorithm> 
    template< class ForwardIt >
constexpr ForwardIt shift_left( ForwardIt first, ForwardIt last,
                                typename std::iterator_traits<ForwardIt>::
                                    difference_type n );
    		(1) (C++20 起) 
    template< class ExecutionPolicy, class ForwardIt >
ForwardIt shift_left( ExecutionPolicy&& policy,
                      ForwardIt first, ForwardIt last,
                      typename std::iterator_traits<ForwardIt>::
                          difference_type n );
    		(2) (C++20 起) 
    template< class ForwardIt >
constexpr ForwardIt shift_right( ForwardIt first, ForwardIt last,
                                 typename std::iterator_traits<ForwardIt>::
                                     difference_type n );
    		(3) (C++20 起) 
    template< class ExecutionPolicy, class ForwardIt >
ForwardIt shift_right( ExecutionPolicy&& policy,
                       ForwardIt first, ForwardIt last,
                       typename std::iterator_traits<ForwardIt>::
                           difference_type n );
    		(4) (C++20 起)

    将范围 [first, last) 中的元素移位 n 个位置。

    1) 将元素向范围的起始方向移位。
    • 若 n == 0 || n >= last - first，则无任何效果。
    • 否则，对于 i 中的每个整数 [0, last - first - n)，将原本位于位置 first + n + i 的元素移动到位置 first + i。
    移位按 i 递增的顺序执行，从 0 开始。
    3) 将元素向范围的末尾方向移位。
    • 若 n == 0 || n >= last - first，则无任何效果。
    • 否则，对于 i 中的每个整数 [0, last - first - n)，将原本位于位置 first + i 的元素移动到位置 first + n + i。
    若 ForwardIt 满足 LegacyBidirectionalIterator 要求，则移位按 i 递减的顺序执行，从 last - first - n - 1 开始。
    2,4) 分别与 (1) 和 (3) 相同，但根据 policy 执行，且移位可以任何顺序进行。
    这些重载仅在 std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> 为 true 时参与重载决议。

    处于原始范围但不在新范围内的元素保留在有效但未指定的状态。

    若满足以下任一条件，则行为未定义：

    参数

    first, last - 定义要移动元素范围的迭代器对
    n - 要移动的位数
    policy - 要使用的执行策略
    类型要求
    -
    ForwardIt 必须满足 LegacyForwardIterator 的要求。

    返回值

    1,2) 结果范围的结束位置。
    3,4) 结果范围的起始位置。

    复杂度

    1,2) 最多进行 std:: distance ( first, last ) - n 次赋值操作。
    3,4) 最多进行 std:: distance ( first, last ) - n 次赋值或交换。

    异常

    带有名为 ExecutionPolicy 模板参数的重载按以下方式报告错误：

    • 如果作为算法一部分调用的函数执行抛出异常，且 ExecutionPolicy 是某个 标准策略 ，则调用 std::terminate 。对于其他任何 ExecutionPolicy ，其行为由实现定义。
    • 如果算法无法分配内存，则抛出 std::bad_alloc 。

    注释

    功能测试 宏 值 标准 功能
    __cpp_lib_shift 201806L (C++20) std::shift_left 和 std::shift_right

    示例

    运行此代码 
    #include <algorithm>
#include <iostream>
#include <string>
#include <type_traits>
#include <vector>
struct S
{
    int value{0};
    bool specified_state{true};
    S(int v = 0) : value{v} {}
    S(S const& rhs) = default;
    S(S&& rhs) { *this = std::move(rhs); }
    S& operator=(S const& rhs) = default;
    S& operator=(S&& rhs)
    {
        if (this != &rhs)
        {
            value = rhs.value;
            specified_state = rhs.specified_state;
            rhs.specified_state = false;
        }
        return *this;
    }
};
template<typename T>
std::ostream& operator<<(std::ostream& os, std::vector<T> const& v)
{
    for (const auto& s : v)
    {
        if constexpr (std::is_same_v<T, S>)
            s.specified_state ? os << s.value << ' ' : os << ". ";
        else if constexpr (std::is_same_v<T, std::string>)
            os << (s.empty() ? "." : s) << ' ';
        else
            os << s << ' ';
    }
    return os;
}
int main()
{
    std::cout << std::left;
    std::vector<S>           a{1, 2, 3, 4, 5, 6, 7};
    std::vector<int>         b{1, 2, 3, 4, 5, 6, 7};
    std::vector<std::string> c{"α", "β", "γ", "δ", "ε", "ζ", "η"};
    std::cout << "vector<S> \tvector<int> \tvector<string>\n";
    std::cout << a << "  " << b << "  " << c << '\n';
    std::shift_left(begin(a), end(a), 3);
    std::shift_left(begin(b), end(b), 3);
    std::shift_left(begin(c), end(c), 3);
    std::cout << a << "  " << b << "  " << c << '\n';
    std::shift_right(begin(a), end(a), 2);
    std::shift_right(begin(b), end(b), 2);
    std::shift_right(begin(c), end(c), 2);
    std::cout << a << "  " << b << "  " << c << '\n';
    std::shift_left(begin(a), end(a), 8); // 无效果：n >= last - first
    std::shift_left(begin(b), end(b), 8); <span

    参阅

    (C++11)
    		 将某一范围的元素移动至新位置
    (函数模板)&(算法函数对象)
    (C++20)
    (C++11)
    		 按逆序将某一范围的元素移动至新位置
    (函数模板)&(算法函数对象)
    (C++20)
    		旋转范围中的元素顺序
    (函数模板)&(算法函数对象)
    (C++20)
    (C++23)(C++23)
    		 移动范围中的元素
    (算法函数对象)