Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::for_each_n(3)	      C++ Standard Libary	    std::for_each_n(3)

NAME
       std::for_each_n - std::for_each_n

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

	  1)  Applies the given	function object	f to the result	of dereferenc-
       ing every iterator
	  in the range [first, first + n), in order.
	  2) Applies the given function	object f to the	result of  dereferenc-
       ing every iterator
	  in  the range	[first,	first +	n) (not	necessarily in order). The al-
       gorithm is
	  executed according to	policy.	This overload does not participate  in
       overload
	  resolution unless
	  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)	is true.

	  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 al-
       lowed to	make copies
	  of the elements in the sequence even if they are trivially copyable.

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.
		      function object, to be applied to	the result of derefer-
       encing every
		      iterator in the range [first, first + n)

		      The  signature  of  the function should be equivalent to
       the following:

	  f	   -  void fun(const Type &a);

		      The signature does not need to have const	&.
		      The type Type must be such that an object	 of  type  In-
       putIt 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.
	  -
	  UnaryFunction	 must meet the requirements of MoveConstructible. Does
       not have	to be
	  CopyConstructible
	  -
	  UnaryFunction2 must meet the requirements of CopyConstructible.

Return value
	  An iterator equal to first  +	 n,  or	 more  formally,  to  std::ad-
       vance(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 ExecutionPolicy is one of the	standard policies, std::termi-
       nate is called.
	      For any other ExecutionPolicy, 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;
	  }

Example
       // Run this code

	#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
	  transform		a destination range
				(function template)
	  range-for loop(C++11)	executes loop over range
	  for_each		applies	a function to a	range of elements
				(function template)
	  ranges::for_each_n	 applies a function object to the first	n ele-
       ments of	a
	  (C++20)		sequence
				(niebloid)

http://cppreference.com		  2022.07.31		    std::for_each_n(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::for_each_n&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help