Difference between revisions of "cpp/algorithm/rotate copy"
From cppreference.com
m (→Example: + gram.) |
(Uses {{mark constexpr since c++20}}.) |
||
(8 intermediate revisions by 4 users not shown) | |||
Line 2: | Line 2: | ||
{{cpp/algorithm/navbar}} | {{cpp/algorithm/navbar}} | ||
{{dcl begin}} | {{dcl begin}} | ||
− | {{dcl header | algorithm}} | + | {{dcl header|algorithm}} |
− | {{dcl | + | {{dcl|num=1|notes={{mark constexpr since c++20}}| |
template< class ForwardIt, class OutputIt > | template< class ForwardIt, class OutputIt > | ||
OutputIt rotate_copy( ForwardIt first, ForwardIt n_first, | OutputIt rotate_copy( ForwardIt first, ForwardIt n_first, | ||
ForwardIt last, OutputIt d_first ); | ForwardIt last, OutputIt d_first ); | ||
− | |||
− | |||
− | |||
− | |||
}} | }} | ||
− | {{dcl | since=c++17 | | + | {{dcl|num=2|since=c++17| |
− | template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > | + | template< class ExecutionPolicy, |
− | ForwardIt2 rotate_copy( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 n_first, | + | class ForwardIt1, class ForwardIt2 > |
− | + | ForwardIt2 rotate_copy( ExecutionPolicy&& policy, | |
+ | ForwardIt1 first, ForwardIt1 n_first, | ||
+ | ForwardIt1 last, ForwardIt2 d_first ); | ||
}} | }} | ||
{{dcl end}} | {{dcl end}} | ||
− | @1@ Copies the elements from the range {{ | + | @1@ Copies the elements from the range {{range|first|last}}, to another range beginning at {{c|d_first}} in such a way, that the element {{c|*(n_first)}} becomes the first element of the new range and {{c|*(n_first - 1)}} becomes the last element. |
+ | |||
+ | @2@ Same as {{v|1}}, but executed according to {{c|policy}}. | ||
+ | @@ {{cpp/algorithm/parallel overload precondition}} | ||
− | + | If any of the following conditions is satisfied, the behavior is undefined: | |
+ | * {{range|first|n_first}} or {{range|n_first|last}} is not a [[cpp/iterator#Ranges|valid range]]. | ||
+ | * The source and destination ranges overlap. | ||
===Parameters=== | ===Parameters=== | ||
{{par begin}} | {{par begin}} | ||
− | {{par | first, last | the range of elements to copy}} | + | {{par|first, last|the range of elements to copy}} |
− | {{par | n_first | an iterator to an element in {{ | + | {{par|n_first|an iterator to an element in {{range|first|last}} that should appear at the beginning of the new range}} |
− | {{par | d_first | beginning of the destination range}} | + | {{par|d_first|beginning of the destination range}} |
{{par exec pol}} | {{par exec pol}} | ||
{{par hreq}} | {{par hreq}} | ||
− | {{par req named | ForwardIt, ForwardIt1, ForwardIt2 | ForwardIterator}} | + | {{par req named|ForwardIt, ForwardIt1, ForwardIt2|ForwardIterator}} |
− | {{par req named | OutputIt | OutputIterator}} | + | {{par req named|OutputIt|OutputIterator}} |
{{par end}} | {{par end}} | ||
Line 38: | Line 41: | ||
===Complexity=== | ===Complexity=== | ||
− | + | Exactly {{c|std::distance(first, last)}} assignments. | |
===Exceptions=== | ===Exceptions=== | ||
Line 44: | Line 47: | ||
===Possible implementation=== | ===Possible implementation=== | ||
− | See also the implementations in [https://github.com/gcc-mirror/gcc/blob/ | + | See also the implementations in [https://github.com/gcc-mirror/gcc/blob/14d8a5ae472ca5743016f37da2dd4770d83dea21/libstdc%2B%2B-v3/include/bits/stl_algo.h#L1440-L1455 libstdc++], [https://github.com/llvm/llvm-project/tree/f221d905b131158cbe3cbc4320d1ecd1376c3f22/libcxx/include/__algorithm/rotate_copy.h libc++], and [https://github.com/microsoft/STL/blob/472161105d596192194d4715ccad307c6c163b4a/stl/inc/algorithm#L4438-L4459 MSVC STL]. |
− | {{eq fun | 1= | + | {{eq fun|1= |
template<class ForwardIt, class OutputIt> | template<class ForwardIt, class OutputIt> | ||
+ | constexpr // since C++20 | ||
OutputIt rotate_copy(ForwardIt first, ForwardIt n_first, | OutputIt rotate_copy(ForwardIt first, ForwardIt n_first, | ||
− | + | ForwardIt last, OutputIt d_first) | |
{ | { | ||
d_first = std::copy(n_first, last, d_first); | d_first = std::copy(n_first, last, d_first); | ||
Line 57: | Line 61: | ||
===Example=== | ===Example=== | ||
{{example | {{example | ||
− | + | |code= | |
− | + | ||
#include <algorithm> | #include <algorithm> | ||
− | |||
#include <iostream> | #include <iostream> | ||
#include <iterator> | #include <iterator> | ||
+ | #include <vector> | ||
int main() | int main() | ||
{ | { | ||
− | std::vector<int> src | + | std::vector<int> src{1, 2, 3, 4, 5}; |
− | auto pivot = std::find(src.begin(), src.end(), 3); | + | std::vector<int> dest(src.size()); |
− | + | auto pivot = std::find(src.begin(), src.end(), 3); | |
− | + | ||
std::rotate_copy(src.begin(), pivot, src.end(), dest.begin()); | std::rotate_copy(src.begin(), pivot, src.end(), dest.begin()); | ||
− | + | for (int i : dest) | |
− | for ( | + | |
std::cout << i << ' '; | std::cout << i << ' '; | ||
− | |||
std::cout << '\n'; | std::cout << '\n'; | ||
− | + | ||
// copy the rotation result directly to the std::cout | // copy the rotation result directly to the std::cout | ||
pivot = std::find(dest.begin(), dest.end(), 1); | pivot = std::find(dest.begin(), dest.end(), 1); | ||
Line 83: | Line 84: | ||
std::cout << '\n'; | std::cout << '\n'; | ||
} | } | ||
− | + | |output= | |
− | 3 4 5 1 2 | + | 3 4 5 1 2 |
− | 1 2 3 4 5 | + | 1 2 3 4 5 |
}} | }} | ||
===See also=== | ===See also=== | ||
{{dsc begin}} | {{dsc begin}} | ||
− | {{dsc inc | cpp/algorithm/dsc rotate}} | + | {{dsc inc|cpp/algorithm/dsc rotate}} |
− | + | {{dsc inc|cpp/algorithm/ranges/dsc rotate_copy}} | |
{{dsc end}} | {{dsc end}} | ||
{{langlinks|de|es|fr|it|ja|pt|ru|zh}} | {{langlinks|de|es|fr|it|ja|pt|ru|zh}} |
Latest revision as of 22:23, 27 March 2024
Defined in header <algorithm>
|
||
template< class ForwardIt, class OutputIt > OutputIt rotate_copy( ForwardIt first, ForwardIt n_first, |
(1) | (constexpr since C++20) |
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > |
(2) | (since C++17) |
1) Copies the elements from the range
[
first,
last)
, to another range beginning at d_first in such a way, that the element *(n_first) becomes the first element of the new range and *(n_first - 1) becomes the last element.2) Same as (1), but executed according to policy.
This overload participates in overload resolution only if
std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is true. |
(until C++20) |
std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> is true. |
(since C++20) |
If any of the following conditions is satisfied, the behavior is undefined:
-
[
first,
n_first)
or[
n_first,
last)
is not a valid range. - The source and destination ranges overlap.
Contents |
[edit] Parameters
first, last | - | the range of elements to copy |
n_first | - | an iterator to an element in [ first, last) that should appear at the beginning of the new range
|
d_first | - | beginning of the destination range |
policy | - | the execution policy to use. See execution policy for details. |
Type requirements | ||
-ForwardIt, ForwardIt1, ForwardIt2 must meet the requirements of LegacyForwardIterator.
| ||
-OutputIt must meet the requirements of LegacyOutputIterator.
|
[edit] Return value
Output iterator to the element past the last element copied.
[edit] Complexity
Exactly std::distance(first, last) assignments.
[edit] Exceptions
The overload with a template parameter named ExecutionPolicy
reports errors as follows:
- If execution of a function invoked as part of the algorithm throws an exception and
ExecutionPolicy
is one of the standard policies, std::terminate is called. For any otherExecutionPolicy
, the behavior is implementation-defined. - If the algorithm fails to allocate memory, std::bad_alloc is thrown.
[edit] Possible implementation
See also the implementations in libstdc++, libc++, and MSVC STL.
[edit] Example
Run this code
#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::find(src.begin(), src.end(), 3); std::rotate_copy(src.begin(), pivot, src.end(), dest.begin()); for (int i : dest) std::cout << i << ' '; std::cout << '\n'; // copy the rotation result directly to the std::cout pivot = std::find(dest.begin(), dest.end(), 1); std::rotate_copy(dest.begin(), pivot, dest.end(), std::ostream_iterator<int>(std::cout, " ")); std::cout << '\n'; }
Output:
3 4 5 1 2 1 2 3 4 5
[edit] See also
rotates the order of elements in a range (function template) | |
(C++20) |
copies and rotate a range of elements (niebloid) |