Namespaces
Variants

    std::for_each_n

    From cppreference.com
     
    C++
     
    Algorithm library
    Constrained algorithms and algorithms on ranges (C++20)
    Constrained algorithms, e.g. ranges::copy, ranges::sort, ...
    Non-modifying sequence operations    
    Batch operations
    (C++17)
    Search operations
    Modifying sequence operations
    Copy operations
    (C++11)
    (C++11)
    (C++11)
    Swap operations
    Transformation operations
    Generation operations
    Removing operations
    Order-changing operations
    (until C++17)(C++11)
    (C++20)(C++20)
    Sampling operations
    (C++17)

    Sorting and related operations
    Partitioning operations
    (C++11)    
    (C++11)

    Sorting operations
    Binary search operations
    (on partitioned ranges)
    Set operations (on sorted ranges)
    Merge operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    (C++11)
    (C++17)
    Lexicographical comparison operations
    (C++20)
    Permutation operations


     
    Defined in header <algorithm> 
    template< class InputIt, class Size, class UnaryFunc >
InputIt for_each_n( InputIt first, Size n, UnaryFunc f );
    		(1) (constexpr since C++20) 
    template< class ExecutionPolicy,
          class ForwardIt, class Size, class UnaryFunc >
ForwardIt for_each_n( ExecutionPolicy&& policy,
                      ForwardIt first, Size n, UnaryFunc f );
    		(2) (since C++17)

    Applies the given function object f to the result of dereferencing every iterator in the range of n elements starting from first. If f returns a result, the result is ignored.

    1) f is applied in order starting from first.
    If UnaryFunc is not MoveConstructible, the behavior is undefined.
    2) f might not be applied in order. The algorithm is executed according to policy.
    Unlike other parallel algorithms, for_each_n is not allowed to make arbitrary copies of elements from ranges.
    This overload participates in overload resolution only if the value of the following expression is true:

    std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

    		(until C++20)

    std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

    		(since C++20)
    If UnaryFunc is not CopyConstructible, the behavior is undefined.

    If n >= 0 is not true, the behavior is undefined.

    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
    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 &.
    The type Type must be such that an object of type InputIt can be dereferenced and then implicitly converted to Type.

    ​

    Type requirements
    -
    InputIt must meet the requirements of LegacyInputIterator.
    -
    ForwardIt must meet the requirements of LegacyForwardIterator.
    -
    Size must be convertible to an integral type.

    Return value

    std::next(first, n)

    Complexity

    Exactly n applications of f.

    Exceptions

    2) During the execution process:
    • If the temporary memory resources required for parallelization are not available, std::bad_alloc is thrown.
    • If an uncaught exception is thrown while accessing objects via an algorithm argument, the behavior is determined by the execution policy (for standard policies, std::terminate is invoked).

    Notes

    If the iterator type (InputIt/ForwardIt) is mutable, f may modify the elements of the range through the dereferenced iterator.

    Possible implementation

    See also the implementation in libstdc++, libc++ and MSVC stdlib. 

    template<class InputIt, class Size, class UnaryFunc>
InputIt for_each_n(InputIt first, Size n, UnaryFunc f)
{
    for (Size i = 0; i < n; ++first, (void) ++i)
        f(*first);
    
    return first;
}

    Example

    Run this code
    #include <algorithm>
#include <iostream>
#include <vector>

void println(const auto& v)
{
    for (auto count{v.size()}; const auto& e : v)
        std::cout << e << (--count ? ", " : "\n");
}

int main()
{
    std::vector<int> vi{1, 2, 3, 4, 5};
    println(vi);
    
    std::for_each_n(vi.begin(), 3, [](auto& n) { n *= 2; });
    println(vi);
}

    Output: 

    1, 2, 3, 4, 5
2, 4, 6, 4, 5

    Defect reports

    The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

    DR Applied to Behavior as published Correct behavior
    LWG 3213
    (P1718R2)     		C++17 Size was not required to be convertible to an integral type required

    See also

    		 applies a function to a range of elements, storing results in a destination range
    (function template & algorithm function object)[edit]
    (C++20)
    range-for loop(C++11) executes loop over range[edit]
    		applies a unary function object to elements from a range
    (function template & algorithm function object)[edit]
    (C++20)
    (C++20)
    		 applies a function object to the first N elements of a sequence
    (algorithm function object)[edit]