# copy

 Category : algorithms Component type: function

## Prototype

```template <class InputIterator, class OutputIterator>
OutputIterator copy(InputIterator first, InputIterator last,
OutputIterator result);
```

## Description

`Copy` copies elements from the range `[first, last)` to the range `[result, result + (last - first))`. That is, it performs the assignments `*result = *first`, `*(result + 1) = *(first + 1)`, and so on. [1] Generally, for every integer `n` from `0` to `last - first`, `copy` performs the assignment `*(result + n) = *(first + n)`. Assignments are performed in forward order, i.e. in order of increasing `n`. [2]

The return value is `result + (last - first)`

## Definition

Defined in the standard header algorithm, and in the nonstandard backward-compatibility header algo.h.

## Requirements on types

• InputIterator is a model of InputIterator.
• OutputIterator is a model of OutputIterator.
• InputIterator's value type is convertible to a type in OutputIterator's set of value types.

## Preconditions

• `[first, last)` is a valid range.
• `result` is not an iterator within the range `[first, last)`.
• There is enough space to hold all of the elements being copied. More formally, the requirement is that `[result, result + (last - first))` is a valid range. [1]

## Complexity

Linear. Exactly `last - first` assignments are performed.

## Example

```Vector<int> V(5);
iota(V.begin(), V.end(), 1);

List<int> L(V.size());
copy(V.begin(), V.end(), L.begin());
assert(equal(V.begin(), V.end(), L.begin()));
```

## Notes

[1] Note the implications of this. `Copy` cannot be used to insert elements into an empty Container : it overwrites elements, rather than inserting elements. If you want to insert elements into a Sequence, you can either use its `insert` member function explicitly, or else you can use `copy` along with an `insert_iterator` adaptor.

[2] The order of assignments matters in the case where the input and output ranges overlap : `copy` may not be used if `result` is in the range `[first, last)`. That is, it may not be used if the beginning of the output range overlaps with the input range, but it may be used if the end of the output range overlaps with the input range; `copy_backward` has opposite restrictions. If the two ranges are completely nonoverlapping, of course, then either algorithm may be used. The order of assignments also matters if `result` is an `ostream_iterator`, or some other iterator whose semantics depends on the order or assignments.

`copy_backward`, `copy_n`