Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/algorithm/rotate copy"

From cppreference.com
< cpp‎ | algorithm
(clarified n_first parameter)
m (Shorten template names. Use {{lc}} where appropriate.)
Line 1: Line 1:
 
{{cpp/title|rotate_copy}}
 
{{cpp/title|rotate_copy}}
 
{{cpp/algorithm/navbar}}
 
{{cpp/algorithm/navbar}}
−
{{ddcl list begin}}
+
{{dcl begin}}
−
{{ddcl list header | algorithm}}
+
{{dcl header | algorithm}}
−
{{ddcl list item |
+
{{dcl |
 
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 );
 
}}
 
}}
−
{{ddcl list end}}
+
{{dcl end}}
  
 
Copies the elements from the range {{tt|[first, last)}}, to another range beginning at {{tt|d_first}} in such a way, that the element {{tt|n_first}} becomes the first element of the new range and {{tt|n_first - 1}} becomes the last element.  
 
Copies the elements from the range {{tt|[first, last)}}, to another range beginning at {{tt|d_first}} in such a way, that the element {{tt|n_first}} becomes the first element of the new range and {{tt|n_first - 1}} becomes the last element.  
  
 
===Parameters===
 
===Parameters===
−
{{param list begin}}
+
{{par begin}}
−
{{param list item | first, last | the range of elements to copy}}
+
{{par | first, last | the range of elements to copy}}
−
{{param list item | n_first | an iterator to an element in {{tt|[first, last)}} that should appear at the beginning of the new range}}
+
{{par | n_first | an iterator to an element in {{tt|[first, last)}} that should appear at the beginning of the new range}}
−
{{param list item | d_first | beginning of the destination range}}
+
{{par | d_first | beginning of the destination range}}
−
{{param list hreq}}
+
{{par hreq}}
−
{{param list req concept | ForwardIt | ForwardIterator}}
+
{{par req concept | ForwardIt | ForwardIterator}}
−
{{param list req concept | OutputIt | OutputIterator}}
+
{{par req concept | OutputIt | OutputIterator}}
−
{{param list end}}
+
{{par end}}
  
 
===Return value===
 
===Return value===
Line 66: Line 66:
  
 
===See also===
 
===See also===
−
{{dcl list begin}}
+
{{dsc begin}}
−
{{dcl list template | cpp/algorithm/dcl list rotate}}
+
{{dsc inc | cpp/algorithm/dcl list rotate}}
−
{{dcl list end}}
+
{{dsc end}}
  
 
[[de:cpp/algorithm/rotate copy]]
 
[[de:cpp/algorithm/rotate copy]]

Revision as of 17:49, 31 May 2013

 
C++
 
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
(C++11)                (C++11)(C++11)

Modifying sequence operations
Copy operations
(C++11)
(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
(C++11)
(C++17)
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
 
Defined in header <algorithm>
template< class ForwardIt, class OutputIt >

OutputIt rotate_copy( ForwardIt first, ForwardIt n_first,

                      ForwardIt last, OutputIt d_first );

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.

Contents

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
Type requirements

Template:par req concept Template:par req concept

Return value

Output iterator to the element past the last element copied.

Possible implementation

template<class ForwardIt, class OutputIt>
OutputIt rotate_copy(ForwardIt first, ForwardIt n_first,
                           ForwardIt last, OutputIt d_first)
{
    d_first = std::copy(n_first, last, d_first);
    return std::copy(first, n_first, d_first);
}

Example

Run this code
#include <algorithm>
#include <vector>
#include <iostream>
 
int main()
{
    std::vector<int> src = {1, 2, 3, 4, 5}; 
    auto pivot = std::find(src.begin(), src.end(), 3); 
    std::vector<int> dest(src.size());                                          
 
    std::rotate_copy(src.begin(), pivot, src.end(), dest.begin());
 
    for (const auto &i : dest) {
        std::cout << i << ' ';
    }   
    std::cout << '\n';
}

Output: 

3 4 5 1 2

Complexity

linear in the distance between first and last

See also

Template:cpp/algorithm/dcl list rotate
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/rotate_copy&oldid=49289"