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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::for_each - std::for_each

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

	  1) Applies the given function	object f to the	result of  dereferenc-
       ing every iterator
	  in the range [first, last), in order.
	  2)  Applies the given	function object	f to the result	of dereferenc-
       ing every iterator
	  in the range [first, last) (not necessarily in order). The algorithm
       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.

	  Unlike  the rest of the parallel algorithms, for_each	is not allowed
       to make copies
	  of the elements in the sequence even if they are trivially copyable.

Parameters
	  first, last -	the range 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	deref-
       erencing	every
			iterator in the	range [first, last)

			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
	  1)
	  f
	  (until C++11)
	  std::move(f)
	  (since C++11)
	  2) (none)

Complexity
	  Exactly last - first 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 implementations in libstdc++, libc++ and	MSVC stdlib.

	  template<class InputIt, class	UnaryFunction>
	  constexpr UnaryFunction for_each(InputIt first, InputIt last,	Unary-
       Function	f)
	  {
	      for (; first != last; ++first) {
		  f(*first);
	      }
	      return f;	// implicit move since C++11
	  }

Example
	  The following	example	uses a lambda function to increment all	of the
       elements	of a
	  vector  and  then uses an overloaded operator() in a functor to com-
       pute their sum.
	  Note that to compute the sum,	it is recommended to use the dedicated
       algorithm
	  std::accumulate.

       // Run this code

	#include <vector>
	#include <algorithm>
	#include <iostream>

	struct Sum
	{
	    void operator()(int	n) { sum += n; }
	    int	sum{0};
	};

	int main()
	{
	    std::vector<int> nums{3, 4,	2, 8, 15, 267};

	    auto print = [](const int& n) { std::cout << " " <<	n; };

	    std::cout << "before:";
	    std::for_each(nums.cbegin(), nums.cend(), print);
	    std::cout << '\n';

	    std::for_each(nums.begin(),	nums.end(), [](int &n){	n++; });

	    // calls Sum::operator() for each number
	    Sum	s = std::for_each(nums.begin(),	nums.end(), Sum());

	    std::cout << "after: ";
	    std::for_each(nums.cbegin(), nums.cend(), print);
	    std::cout << '\n';
	    std::cout << "sum: " << s.sum << '\n';
	}

Output:
	before:	3 4 2 8	15 267
	after:	4 5 3 9	16 268
	sum: 305

See also
				applies	a function to  a  range	 of  elements,
       storing results in
	  transform		a destination range
				(function template)
	  for_each_n		 applies a function object to the first	n ele-
       ments of	a
	  (C++17)		sequence
				(function template)
	  ranges::for_each	applies	a function to a	range of elements
	  (C++20)		(niebloid)
	  ranges::for_each_n	applies	a function object to the first n  ele-
       ments of	a
	  (C++20)		sequence
				(niebloid)
	  range-for loop(C++11)	executes loop over range

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

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

home | help