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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::min_element	- std::min_element

Synopsis
	  Defined in header <algorithm>
	  template< class ForwardIt >
	  ForwardIt   min_element(  ForwardIt  first,			(until
       C++17)
	  ForwardIt last );
	  template< class ForwardIt >
	  constexpr  ForwardIt	min_element(  ForwardIt			(since
       C++17)
	  first, ForwardIt last	);
	  template< class ExecutionPolicy, class ForwardIt
	  >
							       (2)	(since
       C++17)
	  ForwardIt min_element( ExecutionPolicy&& policy,

	  ForwardIt first, ForwardIt last );		   (1)
	  template< class ForwardIt, class Compare >
	  ForwardIt	     min_element(	    ForwardIt		first,
       (until C++17)
	  ForwardIt last, Compare comp );
	  template< class ForwardIt, class Compare >
	  constexpr	     ForwardIt		min_element(	     ForwardIt
       (since C++17)
	  first, ForwardIt last, Compare comp );	       (3)
	  template< class ExecutionPolicy, class
	  ForwardIt, class Compare >
								   (4)
       (since C++17)
	  ForwardIt min_element( ExecutionPolicy&& policy,

	  ForwardIt first, ForwardIt last, Compare comp	);

	  Finds	the smallest element in	the range [first, last).

	  1) Elements are compared using operator<.
	  3) Elements are compared using the given binary comparison  function
       comp.
	  2,4)	Same  as  (1,3), but executed according	to policy. These over-
       loads do	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.

Parameters
	  first, last -	forward	iterators defining the range to	examine
	  policy      -	the execution policy to	use. See execution policy  for
       details.
			comparison function object (i.e. an object that	satis-
       fies the
			requirements  of  Compare)  which returns true if a is
       less than b.

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

			bool cmp(const Type1 &a, const Type2 &b);

	  comp	      -	While the signature does not need to have const	&, the
       function	must
			not  modify  the objects passed	to it and must be able
       to accept all
			values of type (possibly const)	Type1  and  Type2  re-
       gardless	of value
			category (thus,	Type1 &	is not allowed
			,  nor	is Type1 unless	for Type1 a move is equivalent
       to a copy
			(since C++11)).
			The types Type1	and Type2 must be such that an	object
       of type
			ForwardIt can be dereferenced and then implicitly con-
       verted to both of
			them.

Type requirements
	  -
	  ForwardIt must meet the requirements of LegacyForwardIterator.

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.

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

Exceptions
	  The overloads	with a template	parameter named	ExecutionPolicy	report
       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
First version
	  template<class ForwardIt>
	  ForwardIt min_element(ForwardIt first, ForwardIt last)
	  {
	      if (first	== last) return	last;

	      ForwardIt	smallest = first;
	      ++first;
	      for (; first != last; ++first) {
		  if (*first < *smallest) {
		      smallest = first;
		  }
	      }
	      return smallest;
	  }

Second version
	  template<class ForwardIt, class Compare>
	  ForwardIt min_element(ForwardIt first, ForwardIt last, Compare comp)
	  {
	      if (first	== last) return	last;

	      ForwardIt	smallest = first;
	      ++first;
	      for (; first != last; ++first) {
		  if (comp(*first, *smallest)) {
		      smallest = first;
		  }
	      }
	      return smallest;
	  }

Example
       // Run this code

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

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

	    std::vector<int>::iterator	result	=  std::min_element(v.begin(),
       v.end());
	    std::cout << "min element at: "  <<	 std::distance(v.begin(),  re-
       sult);
	}

Output:
	min element at:	1

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

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

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

home | help