template<class InputIterator, class OutputIterator>
OutputIterator copy(InputIterator first, InputIterator last,
OutputIterator result);
Requires: result shall not be in the range
[first, last). Effects: Copies elements in the range
[first, last) into the range
[result, result + (last - first)) starting from
first and proceeding to
last. For each non-negative integer
n < (last - first), performs
*(result + n) = *(first + n).Returns: result + (last - first). Complexity: Exactly
last - first assignments
. template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 copy(ExecutionPolicy&& policy,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result);
Requires: The ranges
[first, last) and
[result, result + (last - first)) shall not overlap
. Effects: Copies elements in the range
[first, last) into
the range
[result, result + (last - first)). For each non-negative integer
n < (last - first),
performs
*(result + n) = *(first + n).Returns: result + (last - first). Complexity: Exactly
last - first assignments
. template<class InputIterator, class Size, class OutputIterator>
OutputIterator copy_n(InputIterator first, Size n,
OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class Size, class ForwardIterator2>
ForwardIterator2 copy_n(ExecutionPolicy&& exec,
ForwardIterator1 first, Size n,
ForwardIterator2 result);
Effects: For each non-negative integer
, performs
*(result + i) = *(first + i). Complexity: Exactly
n assignments
. template<class InputIterator, class OutputIterator, class Predicate>
OutputIterator copy_if(InputIterator first, InputIterator last,
OutputIterator result, Predicate pred);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Predicate>
ForwardIterator2 copy_if(ExecutionPolicy&& exec,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result, Predicate pred);
Requires: The ranges
[first, last) and
[result, result + (last - first)) shall not overlap
. [
Note: For the overload with an
ExecutionPolicy, there may be a performance
cost if
iterator_traits<ForwardIterator1>::value_type is not
MoveConstructible (Table
23)
. —
end note ]
Effects: Copies all of the elements referred to by the iterator
i in the range
[first, last)
for which
pred(*i) is
true. Returns: The end of the resulting range
. Complexity: Exactly
last - first applications of the corresponding predicate
. template<class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2
copy_backward(BidirectionalIterator1 first,
BidirectionalIterator1 last,
BidirectionalIterator2 result);
Requires:
result
shall not be in the range
(first, last]. Effects:
Copies elements in the range
[first, last)
into the
range
[result - (last-first), result)
starting from
last - 1
and proceeding to
first.
For each positive integer
n <= (last - first),
performs
*(result - n) = *(last - n).Returns:
result - (last - first). Complexity:
Exactly
last - first
assignments
. template<class InputIterator, class OutputIterator>
OutputIterator move(InputIterator first, InputIterator last, OutputIterator result);
Requires:
result
shall not be in the range
[first, last). Effects:
Moves elements in the range
[first, last)
into the range
[result, result + (last - first))
starting from first and proceeding to last
. For each non-negative integer
n < (last-first),
performs
*(result + n) = std::move(*(first + n)).Returns:
result + (last - first). Complexity:
Exactly
last - first
move assignments
. template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 move(ExecutionPolicy&& policy,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result);
Requires: The ranges
[first, last) and
[result, result + (last - first)) shall not overlap
. Effects: Moves elements in the range
[first, last) into
the range
[result, result + (last - first)). For each non-negative integer
n < (last - first),
performs
*(result + n) = std::move(*(first + n)).Returns: result + (last - first). Complexity: Exactly
last - first assignments
. template<class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2
move_backward(BidirectionalIterator1 first,
BidirectionalIterator1 last,
BidirectionalIterator2 result);
Requires:
result
shall not be in the range
(first, last]. Effects:
Moves elements in the range
[first, last)
into the
range
[result - (last-first), result)
starting from
last - 1
and proceeding to first
.
For each positive integer
n <= (last - first),
performs
*(result - n) = std::move(*(last - n)).Returns:
result - (last - first). Complexity:
Exactly
last - first
assignments
. template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator2
swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2
swap_ranges(ExecutionPolicy&& exec,
ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2);
Requires:
The two ranges
[first1, last1)
and
[first2, first2 + (last1 - first1))
shall not overlap
. Effects:
For each non-negative integer
n < (last1 - first1)
performs:
swap(*(first1 + n), *(first2 + n)). Returns:
first2 + (last1 - first1). Complexity:
Exactly
last1 - first1
swaps
. template<class ForwardIterator1, class ForwardIterator2>
void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
Requires:
a and
b shall be dereferenceable
. Effects:
As if by
swap(*a, *b). template<class ForwardIterator, class T>
void replace(ForwardIterator first, ForwardIterator last,
const T& old_value, const T& new_value);
template<class ExecutionPolicy, class ForwardIterator, class T>
void replace(ExecutionPolicy&& exec,
ForwardIterator first, ForwardIterator last,
const T& old_value, const T& new_value);
template<class ForwardIterator, class Predicate, class T>
void replace_if(ForwardIterator first, ForwardIterator last,
Predicate pred, const T& new_value);
template<class ExecutionPolicy, class ForwardIterator, class Predicate, class T>
void replace_if(ExecutionPolicy&& exec,
ForwardIterator first, ForwardIterator last,
Predicate pred, const T& new_value);
Requires:
The expression
*first = new_value
shall be valid
. Effects:
Substitutes elements referred by the iterator
i
in the range
[first, last)
with
new_value,
when the following corresponding conditions hold:
*i == old_value,
pred(*i) != false. Complexity:
Exactly
last - first
applications of the corresponding predicate
. template<class InputIterator, class OutputIterator, class T>
OutputIterator
replace_copy(InputIterator first, InputIterator last,
OutputIterator result,
const T& old_value, const T& new_value);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
ForwardIterator2
replace_copy(ExecutionPolicy&& exec,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result,
const T& old_value, const T& new_value);
template<class InputIterator, class OutputIterator, class Predicate, class T>
OutputIterator
replace_copy_if(InputIterator first, InputIterator last,
OutputIterator result,
Predicate pred, const T& new_value);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
class Predicate, class T>
ForwardIterator2
replace_copy_if(ExecutionPolicy&& exec,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result,
Predicate pred, const T& new_value);
The ranges
[first, last)
and
[result, result + (last - first))
shall not overlap
. Effects:
Assigns to every iterator
i
in the
range
[result, result + (last - first))
either
new_value
or
*(first + (i - result))
depending on whether the following corresponding conditions hold:
*(first + (i - result)) == old_value
pred(*(first + (i - result))) != false
Returns:
result + (last - first). Complexity:
Exactly
last - first
applications of the corresponding predicate
. template<class ForwardIterator, class T>
void fill(ForwardIterator first, ForwardIterator last, const T& value);
template<class ExecutionPolicy, class ForwardIterator, class T>
void fill(ExecutionPolicy&& exec,
ForwardIterator first, ForwardIterator last, const T& value);
template<class OutputIterator, class Size, class T>
OutputIterator fill_n(OutputIterator first, Size n, const T& value);
template<class ExecutionPolicy, class ForwardIterator, class Size, class T>
ForwardIterator fill_n(ExecutionPolicy&& exec,
ForwardIterator first, Size n, const T& value);
Effects:
The
fill algorithms assign
value through all the iterators in the range
[first, last). The
fill_n algorithms assign
value
through all the iterators in the range
[first, first + n)
if
n is positive, otherwise they do nothing
.Returns: fill_n returns
first + n for non-negative values of
n
and
first for negative values
. Complexity:
Exactly
last - first,
n, or 0 assignments, respectively
. template<class ForwardIterator, class Generator>
void generate(ForwardIterator first, ForwardIterator last,
Generator gen);
template<class ExecutionPolicy, class ForwardIterator, class Generator>
void generate(ExecutionPolicy&& exec,
ForwardIterator first, ForwardIterator last,
Generator gen);
template<class OutputIterator, class Size, class Generator>
OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
template<class ExecutionPolicy, class ForwardIterator, class Size, class Generator>
ForwardIterator generate_n(ExecutionPolicy&& exec,
ForwardIterator first, Size n, Generator gen);
Effects:
The
generate algorithms invoke the function object
gen and assign the return
value of
gen through all the iterators in the range
[first, last). The
generate_n algorithms invoke the function object
gen and assign the return value of
gen through all the iterators in
the range
[first, first + n) if
n is positive,
otherwise they do nothing
.Returns: generate_n returns
first + n for non-negative values of
n
and
first for negative values
. Complexity:
Exactly
last - first,
n, or 0
invocations of
gen and assignments, respectively
. template<class ForwardIterator, class T>
ForwardIterator remove(ForwardIterator first, ForwardIterator last,
const T& value);
template<class ExecutionPolicy, class ForwardIterator, class T>
ForwardIterator remove(ExecutionPolicy&& exec,
ForwardIterator first, ForwardIterator last,
const T& value);
template<class ForwardIterator, class Predicate>
ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
Predicate pred);
template<class ExecutionPolicy, class ForwardIterator, class Predicate>
ForwardIterator remove_if(ExecutionPolicy&& exec,
ForwardIterator first, ForwardIterator last,
Predicate pred);
Requires:
The type of
*first
shall satisfy the
MoveAssignable
requirements (Table
25)
. Effects:
Eliminates all the elements referred to by iterator
i
in the range
[first, last)
for which the following corresponding conditions hold:
*i == value, pred(*i) != false. Returns:
The end of the resulting range
. Complexity:
Exactly
last - first
applications of the corresponding predicate
. [
Note: Each element in the range
[ret, last), where
ret is
the returned value, has a valid but unspecified state, because the algorithms
can eliminate elements by moving from elements that were originally
in that range
. —
end note ]
template<class InputIterator, class OutputIterator, class T>
OutputIterator
remove_copy(InputIterator first, InputIterator last,
OutputIterator result, const T& value);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class T>
ForwardIterator2
remove_copy(ExecutionPolicy&& exec,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result, const T& value);
template<class InputIterator, class OutputIterator, class Predicate>
OutputIterator
remove_copy_if(InputIterator first, InputIterator last,
OutputIterator result, Predicate pred);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Predicate>
ForwardIterator2
remove_copy_if(ExecutionPolicy&& exec,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result, Predicate pred);
Requires:
The ranges
[first, last)
and
[result, result + (last - first))
shall not overlap
. The expression
*result = *first shall be valid
.[
Note: For the overloads with an
ExecutionPolicy, there may be a performance
cost if
iterator_traits<ForwardIterator1>::value_type is not
MoveConstructible (Table
23)
. —
end note ]
Effects:
Copies all the elements referred to by the iterator
i
in the range
[first, last)
for which the following corresponding conditions do not hold:
*i == value, pred(*i) != false. Returns:
The end of the resulting range
. Complexity:
Exactly
last - first
applications of the corresponding predicate
. template<class ForwardIterator>
ForwardIterator unique(ForwardIterator first, ForwardIterator last);
template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator unique(ExecutionPolicy&& exec,
ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class BinaryPredicate>
ForwardIterator unique(ForwardIterator first, ForwardIterator last,
BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator, class BinaryPredicate>
ForwardIterator unique(ExecutionPolicy&& exec,
ForwardIterator first, ForwardIterator last,
BinaryPredicate pred);
Requires:
The comparison function shall be an equivalence relation
. The type of
*first shall satisfy the
MoveAssignable requirements (Table
25)
.Effects:
For a nonempty range, eliminates all but the first element from every
consecutive group of equivalent elements referred to by the iterator
i
in the range
[first + 1, last)
for which the following conditions hold:
*(i - 1) == *i
or
pred(*(i - 1), *i) != false. Returns:
The end of the resulting range
. Complexity:
For nonempty ranges, exactly
(last - first) - 1
applications of the corresponding predicate
. template<class InputIterator, class OutputIterator>
OutputIterator
unique_copy(InputIterator first, InputIterator last,
OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2
unique_copy(ExecutionPolicy&& exec,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result);
template<class InputIterator, class OutputIterator,
class BinaryPredicate>
OutputIterator
unique_copy(InputIterator first, InputIterator last,
OutputIterator result, BinaryPredicate pred);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
class BinaryPredicate>
ForwardIterator2
unique_copy(ExecutionPolicy&& exec,
ForwardIterator1 first, ForwardIterator1 last,
ForwardIterator2 result, BinaryPredicate pred);
Requires:
The comparison function shall be an equivalence relation
.The ranges
[first, last)
and
[result, result+(last-first))
shall not overlap
.The expression
*result = *first
shall be valid
.For the overloads with no
ExecutionPolicy,
let
T be the value type of
InputIterator.If
InputIterator meets the forward iterator requirements,
then there are no additional requirements for
T.Otherwise, if
OutputIterator meets the forward iterator
requirements and its value type is the same as
T,
then
T shall be
CopyAssignable (Table
26)
.Otherwise,
T shall be both
CopyConstructible (Table
24) and
CopyAssignable.[
Note: For the overloads with an
ExecutionPolicy, there may be a performance
cost if the value type of
ForwardIterator1 is not both
CopyConstructible and
CopyAssignable. —
end note ]
Effects:
Copies only the first element from every consecutive group of equal elements referred to by
the iterator
i
in the range
[first, last)
for which the following corresponding conditions hold:
*i == *(i - 1)
or
pred(*i, *(i - 1)) != false. Returns:
The end of the resulting range
. Complexity:
For nonempty ranges, exactly
last - first - 1
applications of the corresponding predicate
. template<class BidirectionalIterator>
void reverse(BidirectionalIterator first, BidirectionalIterator last);
template<class ExecutionPolicy, class BidirectionalIterator>
void reverse(ExecutionPolicy&& exec,
BidirectionalIterator first, BidirectionalIterator last);
Effects:
For each non-negative integer
i < (last - first) / 2,
applies
iter_swap
to all pairs of iterators
first + i, (last - i) - 1. Complexity:
Exactly
(last - first)/2
swaps
. template<class BidirectionalIterator, class OutputIterator>
OutputIterator
reverse_copy(BidirectionalIterator first, BidirectionalIterator last,
OutputIterator result);
template<class ExecutionPolicy, class BidirectionalIterator, class ForwardIterator>
ForwardIterator
reverse_copy(ExecutionPolicy&& exec,
BidirectionalIterator first, BidirectionalIterator last,
ForwardIterator result);
Requires:
The ranges
[first, last)
and
[result, result + (last - first))
shall not overlap
. Effects:
Copies the range
[first, last)
to the range
[result, result + (last - first))
such that
for every non-negative integer
i < (last - first)
the following assignment takes place:
*(result + (last - first) - 1 - i) = *(first + i). Returns:
result + (last - first). Complexity:
Exactly
last - first
assignments
. template<class ForwardIterator>
ForwardIterator
rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
template<class ExecutionPolicy, class ForwardIterator>
ForwardIterator
rotate(ExecutionPolicy&& exec,
ForwardIterator first, ForwardIterator middle, ForwardIterator last);
Requires:
[first, middle)
and
[middle, last)
shall be valid ranges
. The type of
*first shall satisfy
the requirements of
MoveConstructible
(Table
23) and the
requirements of
MoveAssignable
(Table
25)
.Effects:
For each non-negative integer
i < (last - first),
places the element from the position
first + i
into position
first + (i + (last - middle)) % (last - first). Returns: first + (last - middle). Remarks:
This is a left rotate
. Complexity:
At most
last - first
swaps
. template<class ForwardIterator, class OutputIterator>
OutputIterator
rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last,
OutputIterator result);
template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2
rotate_copy(ExecutionPolicy&& exec,
ForwardIterator1 first, ForwardIterator1 middle, ForwardIterator1 last,
ForwardIterator2 result);
Requires:
The ranges
[first, last)
and
[result, result + (last - first))
shall not overlap
. Effects:
Copies the range
[first, last)
to the range
[result, result + (last - first))
such that for each non-negative integer
i < (last - first)
the following assignment takes place:
*(result + i) = *(first +
(i + (middle - first)) % (last - first)). Returns:
result + (last - first). Complexity:
Exactly
last - first
assignments
. template<class PopulationIterator, class SampleIterator,
class Distance, class UniformRandomBitGenerator>
SampleIterator sample(PopulationIterator first, PopulationIterator last,
SampleIterator out, Distance n,
UniformRandomBitGenerator&& g);
Requires:
PopulationIterator shall satisfy the requirements of an input iterator (
[input.iterators])
. Distance shall be an integer type
. remove_reference_t<UniformRandomBitGenerator>
shall meet the requirements of a uniform random bit generator type (
[rand.req.urng])
whose return type is convertible to
Distance. out shall not be in the range
[first, last).
Effects:
Copies
min(last - first, n) elements (the
sample)
from
[first, last) (the
population) to
out
such that each possible sample has equal probability of appearance
. Returns:
The end of the resulting sample range
. Remarks:
Stable if and only if
PopulationIterator satisfies the
requirements of a forward iterator
.To the extent that the implementation of this function makes use of
random numbers, the object
g shall serve as the
implementation's source of randomness
.
template<class RandomAccessIterator, class UniformRandomBitGenerator>
void shuffle(RandomAccessIterator first,
RandomAccessIterator last,
UniformRandomBitGenerator&& g);
The type
remove_reference_t<UniformRandomBitGenerator>
shall meet the requirements of a
uniform random bit generator (
[rand.req.urng]) type whose return type is
convertible to
iterator_traits<RandomAccessIterator>::difference_type. Effects:
Permutes the elements in the range
[first, last)
such that each possible permutation of those elements has equal probability of appearance
. Complexity:
Exactly
(last - first) - 1
swaps
. Remarks:
To the extent that the implementation of this function makes use of random
numbers, the object
g shall serve as the implementation's source of
randomness
.