Difference between revisions of "cpp/algorithm/for each n"
m (→See also: + std::ranges version (TBD for all non-range algos)) |
|||
| Line 58: | Line 58: | ||
f(*first); | f(*first); | ||
} | } | ||
| − | return first; | + | return first + n; |
} | } | ||
}} | }} | ||
Revision as of 09:06, 20 August 2021
| Defined in header <algorithm>
|
||
| (1) | ||
template< class InputIt, class Size, class UnaryFunction > InputIt for_each_n( InputIt first, Size n, UnaryFunction f ); |
(since C++17) (until C++20) |
|
| template< class InputIt, class Size, class UnaryFunction > constexpr InputIt for_each_n( InputIt first, Size n, UnaryFunction f ); |
(since C++20) | |
| template< class ExecutionPolicy, class ForwardIt, class Size, class UnaryFunction2 > ForwardIt for_each_n( ExecutionPolicy&& policy, ForwardIt first, Size n, UnaryFunction2 f ); |
(2) | (since C++17) |
f to the result of dereferencing every iterator in the range [first, first + n), in order. f to the result of dereferencing every iterator in the range [first, first + n) (not necessarily in order). The algorithm is executed according to policy. This overload participates in overload resolution only if |
std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is true. |
(until C++20) |
|
std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> is true. |
(since C++20) |
For both overloads, if the iterator type is mutable, f may modify the elements of the range through the dereferenced iterator. If f returns a result, the result is ignored. If n is less than zero, the behavior is undefined.
Unlike the rest of the parallel algorithms, for_each_n is not allowed to make copies of the elements in the sequence even if they are trivially copyable.
Contents |
Parameters
| first | - | the beginning of the range to apply the function to |
| n | - | the number of elements to apply the function to |
| policy | - | the execution policy to use. See execution policy for details. |
| f | - | function object, to be applied to the result of dereferencing every iterator in the range [first, first + n) The signature of the function should be equivalent to the following: void fun(const Type &a); The signature does not need to have const &. |
| Type requirements | ||
-InputIt must meet the requirements of LegacyInputIterator.
| ||
-ForwardIt must meet the requirements of LegacyForwardIterator.
| ||
-UnaryFunction must meet the requirements of MoveConstructible. Does not have to be CopyConstructible
| ||
-UnaryFunction2 must meet the requirements of CopyConstructible.
| ||
Return value
first + n
Complexity
Exactly n applications of f
Exceptions
The overload with a template parameter named ExecutionPolicy reports errors as follows:
- If execution of a function invoked as part of the algorithm throws an exception and
ExecutionPolicyis one of the standard policies, std::terminate is called. For any otherExecutionPolicy, the behavior is implementation-defined. - If the algorithm fails to allocate memory, std::bad_alloc is thrown.
Possible implementation
See also the implementation in libstdc++, libc++ and MSVC stdlib.
template<class InputIt, class Size, class UnaryFunction> InputIt for_each_n(InputIt first, Size n, UnaryFunction f) { for (Size i = 0; i < n; ++first, (void) ++i) { f(*first); } return first + n; } |
Example
#include <algorithm> #include <iostream> #include <vector> int main() { std::vector<int> ns{1, 2, 3, 4, 5}; for (auto n: ns) std::cout << n << ", "; std::cout << '\n'; std::for_each_n(ns.begin(), 3, [](auto& n){ n *= 2; }); for (auto n: ns) std::cout << n << ", "; std::cout << '\n'; }
Output:
1, 2, 3, 4, 5, 2, 4, 6, 4, 5,
See also
| applies a function to a range of elements, storing results in a destination range (function template) | |
range-for loop(C++11)
|
executes loop over range |
| applies a function to a range of elements (function template) | |
| (C++20) |
applies a function object to the first N elements of a sequence (niebloid) |
