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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::min	- std::min

Synopsis
	  Defined in header <algorithm>
	  template< class T >				       (until
	  const	T& min(	const T& a, const T& b );	       C++14)
	  template< class T >				       (since
	  constexpr const T& min( const	T& a, const T&	       C++14)
	  b );
	  template< class T, class Compare >			       (until
	  const	T& min(	const T& a, const T& b,			       C++14)
	  Compare comp );
	  template< class T, class Compare >			       (since
	  constexpr const T& min( const	T& a, const T&		       C++14)
	  b, Compare comp );
									       (since
	  template<	 class	    T	   >				   (1)
       C++11)
	  T	   min(	       std::initializer_list<T>	       ilist	    );
       (until
							   (2)
       C++14)
	  template<		     class		   T		     >
       (since
	  constexpr	     T		min(	      std::initializer_list<T>
       C++14)
	  ilist	);					       (3)
	  template<	   class	T,	  class	       Compare	     >
       (since
	  T	      min(	     std::initializer_list<T>		ilist,
       C++11)
	  Compare			     comp			    );
       (until
								       (4)
       C++14)
	  template<	  class	       T,	 class	      Compare	     >
       (since
	  constexpr	     T		min(	      std::initializer_list<T>
       C++14)
	  ilist, Compare comp );

	  Returns the smaller of the given values.

	  1-2) Returns the smaller of a	and b.
	  3-4) Returns the smallest of the values in initializer list ilist.

	  The (1,3) versions use operator< to compare the  values,  the	 (2,4)
       versions	use the
	  given	comparison function comp.

Parameters
	  a, b	 -  the	values to compare
	  ilist	 -  initializer	list with the values to	compare
		    comparison	function object	(i.e. an object	that satisfies
       the requirements
		    of Compare)	which returns true if a	is less	than b.

		    The	signature of the comparison function should be equiva-
       lent to the
		    following:

		    bool cmp(const Type1 &a, const Type2 &b);
	  cmp	 -
		    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 regardless 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 T can be
		    implicitly converted to both of them.

Type requirements
	  -
	  T must meet the requirements of LessThanComparable in	order  to  use
       overloads (1,3).
	  -
	  T  must  meet	 the requirements of CopyConstructible in order	to use
       overloads (3,4).

Return value
	  1-2) The smaller of a	and b. If the values are  equivalent,  returns
       a.
	  3-4)	The  smallest value in ilist. If several values	are equivalent
       to the smallest,
	  returns the leftmost such value.

Complexity
	  1-2) Exactly one comparison
	  3-4) Exactly ilist.size() - 1	comparisons

Possible implementation
First version
	  template<class T>
	  const	T& min(const T&	a, const T& b)
	  {
	      return (b	< a) ? b : a;
	  }

Second version
	  template<class T, class Compare>
	  const	T& min(const T&	a, const T& b, Compare comp)
	  {
	      return (comp(b, a)) ? b :	a;
	  }
				   Third version
	  template<class T>
	  T min( std::initializer_list<T> ilist)
	  {
	      return *std::min_element(ilist.begin(), ilist.end());
	  }
				  Fourth version
	  template<class T, class Compare>
	  T min(std::initializer_list<T> ilist,	Compare	comp)
	  {
	      return *std::min_element(ilist.begin(), ilist.end(), comp);
	  }

Notes
	  Capturing the	result of std::min by reference	 produces  a  dangling
       reference if one
	  of the parameters is a temporary and that parameter is returned:

	int n =	1;
	const int& r = std::min(n-1, n+1);
	// r is	dangling

Example
       // Run this code

	#include <algorithm>
	#include <iostream>
	#include <string_view>

	int main()
	{
	    std::cout  <<  "smaller of 1 and 9999 is " << std::min(1, 9999) <<
       '\n'
		      << "smaller of 'a', and 'b' is '"	<< std::min('a',  'b')
       << "'\n"
		      << "shortest of \"foo\", \"bar\",	and \"hello\" is \""
		      << std::min({ "foo", "bar", "hello" },
				  [](const    std::string_view	  s1,	 const
       std::string_view	s2) {
				      return s1.size() < s2.size();
				  }) <<	"\"\n";
	}

Output:
	smaller	of 1 and 9999 is 1
	smaller	of 'a',	and 'b'	is 'a'
	shortest of "foo", "bar", and "hello" is "foo"

See also
	  max	      returns the greater of the given values
		      (function	template)
	  minmax      returns the smaller and larger of	two elements
	  (C++11)     (function	template)
	  min_element returns the smallest element in a	range
		      (function	template)
	  clamp	      clamps a value between a pair of boundary	values
	  (C++17)     (function	template)
	  ranges::min returns the smaller of the given values
	  (C++20)     (niebloid)

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

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

home | help