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<
			std::projected<ranges::iterator_t<R>,  Proj>>  Comp  =
       (2) (since
	  ranges::less							     >
       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 cannot be specified when	 call-
       ing any of them.
	    * None of them are visible to argument-dependent lookup.
	    *  When  any of them are found by normal unqualified lookup	as the
       name to the left
	      of the function-call operator, argument-dependent	lookup is  in-
       hibited.

	  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	last if	the range is  empty  (i.e.,  first  ==
       last).

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;
	       while (++first != last)
		   if  (std::invoke(comp,  std::invoke(proj, *first), std::in-
       voke(proj, *smallest)))
		       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 <array>
	#include <cmath>
	#include <iostream>

	int main()
	{
	    namespace ranges = std::ranges;

	    std::array v{3, 1, -13, 1, 3, 7, -13};

	    auto iterator = ranges::min_element(v.begin(), v.end());
	    auto position = ranges::distance(v.begin(),	iterator);
	    std::cout << "min element is v[" <<	position << "] == " << *itera-
       tor << '\n';

	    auto abs_compare = [](int  a,  int	b)  {  return  (std::abs(a)  <
       std::abs(b)); };
	    iterator = ranges::min_element(v, abs_compare);
	    position = ranges::distance(v.begin(), iterator);
	    std::cout  << "|min| element is v["	<< position << "] == " << *it-
       erator << '\n';
	}

Output:
	min element is v[2] == -13
	|min| element is v[1] == 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		  2024.06.10	   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.1.quarterly>

home | help