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

FreeBSD Manual Pages

  
 
  

home | help 
std::experi...es::for_each(3) C++ Standard Libarystd::experi...es::for_each(3)

NAME
       std::experimental::ranges::for_each	    -	       std::experimen-
       tal::ranges::for_each

Synopsis
	  Defined in header <experimental/ranges/algorithm>
	  template< InputIterator I, Sentinel<I> S, class Proj =
	  ranges::identity,

		    IndirectUnaryInvocable<projected<I,	   Proj>>    Fun     >
       (1) (ranges TS)
	  ranges::tagged_pair<tag::in(I), tag::fun(Fun)>

	      for_each(	I first, S last, Fun f,	Proj proj = Proj{} );
	  template< InputRange R, class	Proj = ranges::identity,

		    IndirectUnaryInvocable<projected<ranges::iterator_t<R>,
	  Proj>>			     Fun			     >
       (2) (ranges TS)
	  ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>),
	  tag::fun(Fun)>

	      for_each(	R&& r, Fun f, Proj proj	= Proj{} );

	  1) Invokes the given function	object f to the	result of invoking the
       projection proj
	  on  dereferencing  every  iterator  in  the  range   [first,	 last)
       (i.e.,ranges::invoke(f,
	  ranges::invoke(proj, *i))), in order.
	  2)  Same  as	(1),  but  uses	 r  as	the  source range, as if using
       ranges::begin(r)	as
	  first	and ranges::end(r) as last.

	  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 algorithms, for_each is not allowed  to  make
       copies of the
	  elements in the sequence even	if they	are trivially copyable.

	  Unlike  std::for_each	(which requires	only MoveConstructible), these
       functions
	  require Fun to model CopyConstructible.

	  Notwithstanding the declarations depicted above, the	actual	number
       and order of
	  template parameters for algorithm declarations is unspecified. Thus,
       if explicit
	  template  arguments  are used	when calling an	algorithm, the program
       is probably
	  non-portable.

Parameters
	  first, last -	the range to apply the function	to
	  r	      -	the range to apply the function	to
	  f	      -	callable object	to be applied to each  projected  ele-
       ment in the range
	  proj	      -	projection to apply to the elements

Return value
	  A tagged_pair	object containing the following	two members:

	    *  The first member, with the tag tag::in, is the past-the-end it-
       erator of the
	      source range (that is, an	iterator of type I that	compares equal
       to the sentinel
	      last).
	    * The second member, with the tag tag::fun,	 is  initialized  from
       std::move(f)
	      (after all applications of the function object).

Complexity
	  Exactly last - first applications of f and proj.

Possible implementation
	  template<InputIterator  I, Sentinel<I> S, class Proj = ranges::iden-
       tity,
		   IndirectUnaryInvocable<ranges::projected<I, Proj>> Fun>
	  auto for_each(I first, S last, Fun f,	Proj proj = Proj{})
	      -> ranges::tagged_pair<tag::in(I), tag::fun(Fun)>
	  {
	      for (; first != last; ++first)
		  ranges::invoke(f, ranges::invoke(proj, *first));
	      return {std::move(first),	std::move(f)};
	  }

Example
	   This	section	is incomplete
	   Reason: no example

See also
	  transform		applies	a function to a	range of elements
				(function template)
	  range-for loop(C++11)	executes loop over range
	  for_each		applies	a function to a	range of elements
				(function template)
	  for_each_n		applies	a function object to the first N  ele-
       ments of	a
	  (C++17)		sequence
				(function template)

Category:
	    * Todo no example

http://cppreference.com		  2024.06.10	 std::experi...es::for_each(3)

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

home | help