Standard Template Library Programmer's Guide

copy_backward , copy_n

Category: algorithms

Component type: function

template

OutputIterator copy_n(InputIterator first, Size count, OutputIterator result);

Copy_n copies elements from the range [first, first + n) to the range [result, result + n) . That is, it performs the assignments *result = *first , *(result + 1) = *(first + 1) , and so on. Generally, for every integer i from 0 up to (but not including) n , copy_n performs the assignment *(result + i) = *(first + i) . Assignments are performed in forward order, i.e. in order of increasing n . [1]

The return value is result + n .

Defined in the standard header algorithm, and in the nonstandard backward-compatibility header algo.h. This function is an SGI extension; it is not part of the C++ standard.

• InputIterator is a model of Input Iterator.

• OutputIterator is a model of Output Iterator.

• Size is an integral type.

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

• n >= 0 .

• [first, first + n) is a valid range.

• result is not an iterator within the range [first, first + n) .

• [result, result + n) is a valid range.

Linear. Exactly n assignments are performed.

vector V(5);

iota(V.begin(), V.end(), 1);

list L(V.size());

copy_n(V.begin(), V.size(), L.begin());

assert(equal(V.begin(), V.end(), L.begin()));

[1] Copy_n is almost, but not quite, redundant. If first is an input iterator, as opposed to a forward iterator, then the copy_n operation can't be expressed in terms of copy .

copy , copy_backward

Category: algorithms

Component type: function

template

BidirectionalIterator2 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result);

Copy_backward copies elements from the range [first, last) to the range [result – (last – first), result) [1]. That is, it performs the assignments *(result – 1) = *(last – 1) , *(result – 2) = *(last – 2) , and so on. Generally, for every integer n from 0 to last – first , copy_backward performs the assignment *(result – n – 1) = *(last – n – 1) . Assignments are performed from the end of the input sequence to the beginning, i.e. in order of increasing n . [2]

The return value is result – (last – first)

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

• BidirectionalIterator1 and BidirectionalIterator2 are models of BidirectionalIterator.

• BidirectionalIterator1's value type is convertible to BidirectionalIterator2's value type.

• [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 – (last – first), result) is a valid range.

Linear. Exactly last – first assignments are performed.

vector V(15);

iota(V.begin(), V.end(), 1);

copy_backward(V.begin(), V.begin() + 10, V.begin() + 15);

[1] Result is an iterator that points to the end of the output range. This is highly unusual: in all other STL algorithms that denote an output range by a single iterator, that iterator points to the beginning of the range.

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

copy , copy_n

Category: algorithms

Component type: function

template

void swap(Assignable& a, Assignable& b);

Assigns the contents of a to b and the contents of b to a . This is used as a primitive operation by many other algorithms.

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

• Assignable is a model of Assignable.

None.

Amortized constant time. [1] [2]

int x = 1;

int y = 2;

assert(x == 1 && y == 2);

swap(x, y);

assert(x == 2 && y == 1);

[1] The time required to swap two objects of type T will obviously depend on the type; "constant time" does not mean that performance will be the same for an 8-bit char as for a 128-bit complex .

[2] This implementation of swap makes one call to a copy constructor and two calls to an assignment operator; roughly, then, it should be expected to take about the same amount of time as three assignments. In many cases, however, it is possible to write a specialized version of swap that is far more efficient. Consider, for example, swapping two vector s each of which has N elements. The unspecialized version requires 3*N assignments of double , but a specialized version requires only nine pointer assignments. This is importantbecause swap is used as a primitive operation in many other STL algorithms, and because containers of containers ( list > , for example) are very common. The STL includes specialized versions of swap for all container classes. User-defined types should also provide specialized versions of swap whenever it is possible to write one that is more efficient than the general version.