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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::ranges::min_element	- std::ranges::min_element

Synopsis
	  Defined in header <algorithm>
	  Call signature
	  template<  std::forward_iterator  I,	std::sentinel_for<I>  S, class
       Proj =
	  std::identity,

	  std::indirect_strict_weak_order<std::projected<I,  Proj>>   Comp   =
       (1) (since
	  ranges::less							     >
       C++20)

	  constexpr I min_element( I first, S last, Comp comp =	{}, Proj  proj
       = {}
	  );
	  template< ranges::forward_range R, class Proj	= std::identity,

	  std::indirect_strict_weak_order<
       (since
	  std::projected<ranges::iterator_t<R>,	 Proj>>	 Comp =	ranges::less >
       (2) C++20)
	  constexpr ranges::borrowed_iterator_t<R>

	  min_element( R&& r, Comp comp	= {}, Proj proj	= {} );

	  1) Finds the smallest	element	in the range [first, last).
	  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.

	  The  function-like  entities	described  on this page	are niebloids,
       that is:

	    * Explicit template	argument lists may not be specified when call-
       ing any of them.
	    * None of them is visible to argument-dependent lookup.
	    * When one of them is found	by normal unqualified lookup  for  the
       name to the left
	      of  the  function-call  operator,	it inhibits argument-dependent
       lookup.

	  In practice, they may	be implemented as function  objects,  or  with
       special compiler
	  extensions.

Parameters
	  first, last -	iterator-sentinel pair denoting	the range to examine
	  r	      -	the range to examine
	  comp	      -	comparison to apply to the projected elements
	  proj	      -	projection to apply to the elements

Return value
	  Iterator to the smallest element in the range	[first,	last). If sev-
       eral elements in
	  the range are	equivalent to the smallest element, returns the	itera-
       tor to the first
	  such element.	Returns	first if the range is empty.

Complexity
	  Exactly  max(N-1,0)  comparisons,  where N = ranges::distance(first,
       last).

Possible implementation
       struct min_element_fn {
	 template<std::forward_iterator	I, std::sentinel_for<I>	S, class  Proj
       = std::identity,
		  std::indirect_strict_weak_order<std::projected<I,	Proj>>
       Comp = ranges::less>
	 constexpr I operator()(I first, S last, Comp comp = {}, Proj  proj  =
       {}) const
	 {
	   if (first ==	last) {
	     return last;
	   }

	   auto	smallest = first;
	   ++first;
	   for (; first	!= last; ++first) {
	       if  (!std::invoke(comp,	std::invoke(proj, *smallest), std::in-
       voke(proj, *first))) {
		   smallest = first;
	       }
	   }
	   return smallest;
	 }

	 template<ranges::forward_range	R, class Proj =	std::identity,
		  std::indirect_strict_weak_order<
		      std::projected<ranges::iterator_t<R>,  Proj>>   Comp   =
       ranges::less>
	 constexpr ranges::borrowed_iterator_t<R>
	 operator()(R&&	r, Comp	comp = {}, Proj	proj = {}) const
	 {
	   return  (*this)(ranges::begin(r),  ranges::end(r),  std::ref(comp),
       std::ref(proj));
	 } };

       inline constexpr	min_element_fn min_element;

Example
       // Run this code

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

	int main()
	{
	    std::vector<int> v{	3, 1, -14, 1, 5, 9 };

	    namespace ranges = std::ranges;
	    auto result	= ranges::min_element(v.begin(), v.end());
	    std::cout << "min element at: " << ranges::distance(v.begin(), re-
       sult) <<	'\n';

	    auto abs_compare = [](int  a,  int	b)  {  return  (std::abs(a)  <
       std::abs(b)); };
	    result = ranges::min_element(v, abs_compare);
	    std::cout  <<  "min	 element  (absolute)  at:  "  <<  ranges::dis-
       tance(v.begin(),	result)	<< '\n';
	}

Output:
	min element at:	2
	min element (absolute) at: 1

See also
	  ranges::max_element	 returns the largest element in	a range
	  (C++20)		 (niebloid)
	  ranges::minmax_element returns the smallest and the largest elements
       in a range
	  (C++20)		 (niebloid)
	  ranges::max		 returns the greater of	the given values
	  (C++20)		 (niebloid)
	  min_element		 returns the smallest element in a range
				 (function template)

http://cppreference.com		  2022.07.31	   std::ranges::min_element(3)

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

home | help