copy, copy_backward

Algorithm

• Summary
• Data Type and Member Function Indexes
• Synopsis
• Description
• Complexity
• Example
• Warnings

Copies a range of elements.

None

#include <algorithm>
template <class InputIterator, class OutputIterator>
 OutputIterator copy(InputIterator first, 
                     InputIterator last,
                     OutputIterator result);
template <class BidirectionalIterator1, 
          class BidirectionalIterator2>
 BidirectionalIterator2
  copy_backward(BidirectionalIterator1 first,
                BidirectionalIterator1 last,
                BidirectionalIterator2 result);

The copy algorithm copies values from the range specified by [first, last) to the range specified by [result, result + (last - first)). copy can be used to copy values from one container to another, or to copy values from one location in a container to another location in the same container, as long as result is not within the range [first-last). copy returns result + (last - first). For each non-negative integer n < (last - first), copy assigns *(first + n) to *(result + n). The result of copy is undefined if result is in the range [first, last).

Unless result is an insert iterator, copy assumes that at least as many elements follow result as are in the range [first, last).

The copy_backward algorithm copies elements in the range specified by [first, last) into the range specified by [result - (last - first), result), starting from the end of the sequence (last-1) and progressing to the front (first). Note that copy_backward does not reverse the order of the elements, it simply reverses the order of transfer. copy_backward returns result - (last - first). You should use copy_backward instead of copy when last is in the range [result - (last - first), result). For each positive integer n <= (last - first), copy_backward assigns *(last - n) to *(result - n). The result of copy_backward is undefined if result is in the range [first, last).

Unless result is an insert iterator, copy_backward assumes that there are at least as many elements ahead of result as are in the range [first, last).

Both copy and copy_backward perform exactly last - first assignments.

   //
   // stdlib/examples/manual/copyex.cpp
   //
 #include <algorithm>
 #include <vector>
 #include <iostream>
 using namespace std;

 int main()
 {
   int d1[4] = {1,2,3,4};
   int d2[4] = {5,6,7,8};

   // Set up three vectors
   //
   vector<int> v1(d1,d1 + 4), v2(d2,d2 + 4), v3(d2,d2 + 4);
   //
   // Set up one empty vector
   //
   vector<int> v4;
   //
   // Copy v1 to v2
   //
   copy(v1.begin(),v1.end(),v2.begin());
   //
   // Copy backwards v1 to v3
   //
   copy_backward(v1.begin(),v1.end(),v3.end());
   //
   // Use insert iterator to copy into empty vector
   //
   copy(v1.begin(),v1.end(),back_inserter(v4));
   //
   // Copy all four to cout
   //
   ostream_iterator<int,char> out(cout," ");
   copy(v1.begin(),v1.end(),out);
   cout << endl;
   copy(v2.begin(),v2.end(),out);
   cout << endl;
   copy(v3.begin(),v3.end(),out);
   cout << endl;
   copy(v4.begin(),v4.end(),out);
   cout << endl;
   
   return 0;
 }

Program Output

1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4

If your compiler does not support default template parameters, then you always need to supply the Allocator template argument. For instance, you have to write:

vector <int, allocator<int> >

instead of:

vector <int>

If your compiler does not support namespaces, then you do not need the using declaration for std.