std::for_each_n - cppreference.com

De cppreference.com

</tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody>

Definido en el archivo de encabezado `<algorithm>`
	(1)
`template< class InputIt, class Size, class UnaryFunction > InputIt for_each_n( InputIt first, Size n, UnaryFunction f );`			(desde C++17) (hasta C++20)
`template< class InputIt, class Size, class UnaryFunction > constexpr InputIt for_each_n( InputIt first, Size n, UnaryFunction f );`			(desde C++20)
`template< class ExecutionPolicy, class ForwardIt, class Size, class UnaryFunction2 > ForwardIt for_each_n( ExecutionPolicy&& policy, ForwardIt first, Size n, UnaryFunction2 f );`		(2)	(desde C++17)

1) Aplica el objeto función dado f al resultado de desreferenciar cada iterador en el rango [first, first + n), en orden.

2) Aplica el objeto función dado f al resultado de desreferenciar cada iterador en el rango [first, first + n) (no necesariamente en orden). El algoritmo se ejecuta de acuerdo a la política policy. Esta sobrecarga no participa en la resolución de sobrecarga a menos que std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (hasta C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (desde C++20) sea verdadera.

Para ambas sobrecargas, el tipo de iterador es mutable; f puede modificar los elementos del rango a través del iterador del que se ha desreferenciado. Si f devuelve un resultado, el resultado se ignora. Si n es menor que cero, el comportamiento no está definido.

A diferencia del resto de los algoritmos paralelos, no se permite que for_each_n haga copias de los elementos en la secuencia, incluso si son trivialmente copiables.

Parámetros

first	-	El inicio del rango al que aplicar la función.
n	-	El número de elementos a los que aplicar la función.
policy	-	La política de ejecución a usar. Véase política de ejecución para más detalles.
f	-	Objeto función Objeto función a aplicarse al resultado de desreferenciar cada iterador en el rango [first, first + n). La signatura de la función deberá ser equivalente a lo siguiente: `void fun(const Type &a);` La signatura no necesita tener `const &`. El tipo `Type` debe ser tal que un objeto del tipo `InputIt` puede ser desreferenciado y entonces convertido implícitamente a `Type`.
Requisitos de tipo
-`InputIt` debe satisfacer los requisitos de InputIterator.
-`ForwardIt` debe satisfacer los requisitos de ForwardIterator.
-`UnaryFunction` debe satisfacer los requisitos de MoveConstructible. No tiene que ser CopyConstructible.
-`UnaryFunction2` debe satisfacer los requisitos de CopyConstructible.

Valor de retorno

Un iterador igual a first + n, o más formalmente, igual a std::advance(first, n).

Complejidad

Exactamente n aplicaciones de f.

Excepciones

La sobrecarga con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reporta errores tales que:

Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la política de ejecución es una de las tres políticas estándar, se llama a std::terminate. Para cualquier otra política de ejecución, el comportamiento está definido por la implementación.
Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.

Posible implementación

Véase también la implementación en libstdc++, libc++ y en 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;
}

Ejemplo

#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';
}

Salida:

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