Standard C++	Library
 		 Copyright 1996, Rogue Wave Software, Inc.

 NAME

   copy,	copy_backward  - Copies	a range	of elements

 SYNOPSIS

   #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);

 DESCRIPTION

   The copy algorithm copies values from	the range specified by  [first
   ,	last) to the range that 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).

 COMPLEXITY

   Both copy  and copy_backward	perform	exactly	last - first
   assignments.

      //

 EXAMPLE

   // stdlib/examples/manual.copyex.cpp
   //
    #include <algorithm>
    #include <vector>
    #include <iostream.h>

   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;
    }

   Output :
   1 2 3	4
   1 2 3	4
   1 2 3	4
   1 2 3	4

 WARNING

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

   vector <int, allocator<int> >

   instead of:

   vector <int>

 STANDARDS CONFORMANCE
   ANSI X3J16/ISO WG21 Joint C++	Committee