27 Algorithms library [algorithms]

27.6 Non-modifying sequence operations [alg.nonmodifying]

27.6.5 For each [alg.foreach]

template<class InputIterator, class Function>
  constexpr Function for_each(InputIterator first, InputIterator last, Function f);

Preconditions: Function meets the Cpp17MoveConstructible requirements (Table 31).

[Note 1:

Function need not meet the requirements of Cpp17CopyConstructible (Table 32).

— end note]

Effects: Applies f to the result of dereferencing every iterator in the range [first, last), starting from first and proceeding to last - 1.

[Note 2:

If the type of first meets the requirements of a mutable iterator, f can apply non-constant functions through the dereferenced iterator.

— end note]

Returns: f.

Complexity: Applies f exactly last - first times.

Remarks: If f returns a result, the result is ignored.

🔗

template<class ExecutionPolicy, class ForwardIterator, class Function>
  void for_each(ExecutionPolicy&& exec,
                ForwardIterator first, ForwardIterator last,
                Function f);

Preconditions: Function meets the Cpp17CopyConstructible requirements.

Effects: Applies f to the result of dereferencing every iterator in the range [first, last).

[Note 3:

If the type of first meets the requirements of a mutable iterator, f can apply non-constant functions through the dereferenced iterator.

— end note]

Complexity: Applies f exactly last - first times.

Remarks: If f returns a result, the result is ignored.

Implementations do not have the freedom granted under [algorithms.parallel.exec] to make arbitrary copies of elements from the input sequence.

[Note 4:

Does not return a copy of its Function parameter, since parallelization often does not permit efficient state accumulation.

— end note]

🔗

template<input_iterator I, sentinel_for<I> S, class Proj = identity,
         indirectly_unary_invocable<projected<I, Proj>> Fun>
  constexpr ranges::for_each_result<I, Fun>
    ranges::for_each(I first, S last, Fun f, Proj proj = {});
template<input_range R, class Proj = identity,
         indirectly_unary_invocable<projected<iterator_t<R>, Proj>> Fun>
  constexpr ranges::for_each_result<borrowed_iterator_t<R>, Fun>
    ranges::for_each(R&& r, Fun f, Proj proj = {});

Effects: Calls invoke(f, invoke(proj, *i)) for every iterator i in the range [first, last), starting from first and proceeding to last - 1.

[Note 5:

If the result of invoke(proj, *i) is a mutable reference, f can apply non-constant functions.

— end note]

Returns: {last, std::move(f)}.

Complexity: Applies f and proj exactly last - first times.

Remarks: If f returns a result, the result is ignored.

[Note 6:

The overloads in namespace ranges require Fun to model copy_constructible .

— end note]

🔗

template<class InputIterator, class Size, class Function>
  constexpr InputIterator for_each_n(InputIterator first, Size n, Function f);

Mandates: The type Size is convertible to an integral type ([conv.integral], [class.conv]).

Preconditions: n >= 0 is true.

Function meets the Cpp17MoveConstructible requirements.

[Note 7:

Function need not meet the requirements of Cpp17CopyConstructible.

— end note]

Effects: Applies f to the result of dereferencing every iterator in the range [first, first + n) in order.

[Note 8:

If the type of first meets the requirements of a mutable iterator, f can apply non-constant functions through the dereferenced iterator.

— end note]

Returns: first + n.

Remarks: If f returns a result, the result is ignored.

🔗

template<class ExecutionPolicy, class ForwardIterator, class Size, class Function>
  ForwardIterator for_each_n(ExecutionPolicy&& exec, ForwardIterator first, Size n,
                             Function f);

Mandates: The type Size is convertible to an integral type ([conv.integral], [class.conv]).

Preconditions: n >= 0 is true.

Function meets the Cpp17CopyConstructible requirements.

Effects: Applies f to the result of dereferencing every iterator in the range [first, first + n).

[Note 9:

If the type of first meets the requirements of a mutable iterator, f can apply non-constant functions through the dereferenced iterator.

— end note]

Returns: first + n.

Remarks: If f returns a result, the result is ignored.

Implementations do not have the freedom granted under [algorithms.parallel.exec] to make arbitrary copies of elements from the input sequence.

🔗

template<input_iterator I, class Proj = identity,
         indirectly_unary_invocable<projected<I, Proj>> Fun>
  constexpr ranges::for_each_n_result<I, Fun>
    ranges::for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {});

Preconditions: n >= 0 is true.

Effects: Calls invoke(f, invoke(proj, *i)) for every iterator i in the range [first, first + n) in order.

[Note 10:

If the result of invoke(proj, *i) is a mutable reference, f can apply non-constant functions.

— end note]

Returns: {first + n, std::move(f)}.

Remarks: If f returns a result, the result is ignored.

[Note 11:

The overload in namespace ranges requires Fun to model copy_constructible .

— end note]