Namespaces
Variants

    std::ranges::shift_left, std::ranges::shift_right

    cppreference.net에서
     
    C++
     
    알고리즘 라이브러리
    제약된 알고리즘 및 범위 기반 알고리즘 (C++20)
    제약된 알고리즘, 예: ranges::copy, ranges::sort, ...
    정렬 및 관련 연산
    분할 연산
    (C++11)    
    (C++11)

    정렬 연산
    이진 검색 연산
    (분할된 범위에 대해)
    집합 연산 (정렬된 범위에 대해)
    병합 연산 (정렬된 범위에 대해)
    힙 연산
    최소/최대 연산
    (C++11)
    (C++17)
    사전식 비교 연산
    (C++20)
    순열 연산


     
    제약된 알고리즘
    이 메뉴의 모든 이름은 네임스페이스에 속함 std::ranges
    비수정 시퀀스 연산
    수정 시퀀스 연산
    분할 연산
    정렬 연산
    이진 검색 연산 (정렬된 범위에 대해)
           
           
        
    집합 연산 (정렬된 범위에 대해)
    힙 연산
    최소/최대 연산
           
           
    순열 연산
    폴드 연산
    수치 연산
    (C++23)            
    초기화되지 않은 저장소에 대한 연산
    반환 유형
     
    헤더에 정의됨 <algorithm>
    호출 시그니처
    		 
    template< std::permutable I, std::sentinel_for<I> S >
constexpr ranges::subrange<I>
    shift_left( I first, S last, std::iter_difference_t<I> n );
    		(1) (C++23부터) 
    template< ranges::forward_range R >
requires std::permutable<ranges::iterator_t<R>>
constexpr ranges::borrowed_subrange_t<R>
    shift_left( R&& r, ranges::range_difference_t<R> n );
    		(2) (C++23부터) 
    template< std::permutable I, std::sentinel_for<I> S >
constexpr ranges::subrange<I>
    shift_right( I first, S last, std::iter_difference_t<I> n );
    		(3) (C++23부터) 
    template< ranges::forward_range R >
requires std::permutable<ranges::iterator_t<R>>
constexpr ranges::borrowed_subrange_t<R>
    shift_right( R&& r, ranges::range_difference_t<R> n );
    		(4) (C++23부터)

    범위 [first, last) 또는 r의 요소들을 n 위치만큼 이동시킵니다. [first, last)이(가) 유효한 범위가 아니면 동작은 정의되지 않습니다.

    1) 범위의 시작 방향으로 요소들을 이동시킵니다:
    • 만약 n == 0 || n >= last - first이면, 아무 효과가 없습니다.
    • 만약 n < 0이면, 동작은 정의되지 않습니다.
    • 그렇지 않으면, i의 모든 정수 [0, last - first - n)에 대해, 원래 위치 first + n + i에 있던 요소를 위치 first + i로 이동시킵니다. 이동은 i의 증가하는 순서로 0부터 시작하여 수행됩니다.
    3) 범위의 끝 방향으로 요소들을 이동시킵니다:
    • 만약 n == 0 || n >= last - first이면, 아무 효과가 없습니다.
    • 만약 n < 0이면, 동작은 정의되지 않습니다.
    • 그렇지 않으면, i의 모든 정수 [0, last - first - n)에 대해, 원래 위치 first + i에 있던 요소를 위치 first + n + i로 이동시킵니다. 만약 I가 bidirectional_iterator를 모델화하면, 이동은 i의 감소하는 순서로 last - first - n - 1부터 시작하여 수행됩니다.
    2,4) 각각 (1) 또는 (3)과 동일하지만, 범위로 r을 사용하며, ranges::begin(r)을 first로, ranges::end(r)를 last으로 사용하는 것과 같습니다.

    원래 범위에 있었지만 새 범위에는 없는 요소들은 유효하지만 지정되지 않은 상태로 남습니다.

    이 페이지에 설명된 함수형 엔터티는 알고리즘 함수 객체 (비공식적으로 niebloids로 알려짐)입니다. 즉:

    • 그들 중 어떤 것을 호출할 때 명시적 템플릿 인자 목록을 지정할 수 없습니다.
    • 그들 중 어느 것도 인자 종속 조회에 보이지 않습니다.
    • 그들 중 어떤 것이 함수 호출 연산자의 왼쪽 이름으로 보통의 비한정 조회에 의해 발견되면, 인자 종속 조회가 억제됩니다.

    매개변수

    first, last - 이동할 요소들의 범위 를 정의하는 반복자-감시자 쌍
    r - 이동할 요소들의 범위
    n - 이동할 위치의 수

    반환값

    1,2) { first, /*NEW_LAST*/ } , 여기서 NEW_LAST 는 결과 범위의 끝이며 다음과 동일합니다:
    • first + ( last - first - n ) , 만약 n 이 last - first 보다 작은 경우;
    • first 그렇지 않은 경우.
    3,4) { /*NEW_FIRST*/ , last } , 여기서 NEW_FIRST 는 결과 범위의 시작 부분이며 다음 값과 동일합니다:
    • first + n , 만약 n 이 last - first 보다 작은 경우;
    • last 그 외의 경우.

    복잡도

    1,2) 최대 ranges:: distance ( first, last ) - n 번의 할당.
    3,4) 최대 ranges:: distance ( first, last ) - n 번의 할당 또는 교환.

    참고 사항

    ranges::shift_left / ranges::shift_right 는 I 가 bidirectional_iterator 또는 (더 나은 경우) random_access_iterator 를 모델링할 경우 일반적인 구현에서 더 나은 효율성을 가집니다.

    구현체들(예: MSVC STL )은 반복자 타입이 contiguous_iterator 를 모델링하고 해당 값 타입의 교환이 비트리비얼 특수 멤버 함수나 ADL 에서 발견된 swap 을 호출하지 않을 때 벡터화를 활성화할 수 있습니다.

    기능 테스트 매크로 값 표준 기능
    __cpp_lib_shift 202202L (C++23) std::ranges::shift_left 및 std::ranges::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::ranges::shift_left(a, 3);
    std::ranges::shift_left(b, 3);
    std::ranges::shift_left(c, 3);
    std::cout << a << "  " << b << "  " << c << '\n';
    std::ranges::shift_right(a, 2);
    std::ranges::shift_right(b, 2);
    std::ranges::shift_right(c, 2);
    std::cout << a << "  " << b << "  " << c << '\n';
    std::ranges::shift_left(a, 8); // 효과 없음: n >= last - first
    std::ranges::shift_left(b, 8); // 동일
    std::ranges::shift_left(c, 8); // 동일
    std::cout << a << "  " << b << "  " << c << '\n';
//  std::ranges::shift_left(a, -3); // UB
}

    가능한 출력: 

    vector<S>       vector<int>     vector<string>
1 2 3 4 5 6 7   1 2 3 4 5 6 7   α β γ δ ε ζ η
4 5 6 7 . . .   4 5 6 7 5 6 7   δ ε ζ η . . .
. . 4 5 6 7 .   4 5 4 5 6 7 5   . . δ ε ζ η .
. . 4 5 6 7 .   4 5 4 5 6 7 5   . . δ ε ζ η .

    같이 보기

    (C++20)
    		 요소 범위를 새 위치로 이동합니다
    (알고리즘 함수 객체)
    (C++20)
    		 요소 범위를 역순으로 새 위치로 이동합니다
    (알고리즘 함수 객체)
    (C++20)
    		 범위 내 요소의 순서를 회전합니다
    (알고리즘 함수 객체)
    (C++20)(C++20)
    		 범위 내 요소를 이동합니다
    (함수 템플릿)