Namespaces
Variants

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

From cppreference.net
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Constrained algorithms
All names in this menu belong to namespace std::ranges
Non-modifying sequence operations
Modifying sequence operations
Partitioning operations
Sorting operations
Binary search operations (on sorted ranges)
Set operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Permutation operations
Fold operations
Operations on uninitialized storage
Return types
헤더 파일에 정의됨 <algorithm>
함수 시그니처
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부터)

[ first , last ) 범위의 왼쪽 회전 result 에 복사합니다.

1) 소스 범위의 요소들을 대상 범위로 복사합니다. [ first , last ) 에서, 대상 범위에서는 [ first , middle ) 의 요소들이 [ middle , last ) 의 요소들 뒤에 위치하도록 하며, 두 범위 내 요소들의 순서는 유지됩니다.
다음 중 하나라도 해당되면 동작은 정의되지 않습니다: [ first , middle ) 또는 [ middle , last ) 가 유효한 범위가 아니거나, 소스 범위와 대상 범위가 겹치는 경우.
2) (1) 과 동일하지만, r 을 소스 범위로 사용하며, 마치 ranges:: begin ( r ) first 로, ranges:: end ( r ) last 로 사용하는 것과 같습니다.

이 페이지에서 설명하는 함수형 개체들은 algorithm function objects (일반적으로 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';
    // 회전 결과를 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

참고 항목

범위 내 요소들의 순서를 회전시킵니다
(알고리즘 함수 객체)
요소들의 범위를 새로운 위치로 복사합니다
(알고리즘 함수 객체)
요소들의 범위를 복사하고 회전시킵니다
(함수 템플릿)