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 >					   (1) (const-
       expr since C++14)
	  const	T& min(	const T& a, const T& b );
	  template< class T, class Compare >			  (2)  (const-
       expr since C++14)
	  const	T& min(	const T& a, const T& b,	Compare	comp );
	  template<  class  T  >				    (3)	(since
       C++11)
	  T min( std::initializer_list<T> ilist	 );		       (const-
       expr since C++14)
	  template<  class  T,	class Compare >			    (4)	(since
       C++11)
	  T min( std::initializer_list<T> ilist, Compare comp  );      (const-
       expr since C++14)

	  Returns the smaller of the given values.

	  1,2) Returns the smaller of a	and b.
	  1) Uses operator< to compare the values.
	  If T is not LessThanComparable, the behavior is undefined.
	  2) Use the comparison	function comp to compare the values.
	  3,4) Returns the smallest of the values in initializer list ilist.
	  If ilist.size() is zero, or T	is not CopyConstructible, the behavior
       is undefined.
	  3) Uses operator< to compare the values.
	  If T is not LessThanComparable, the behavior is undefined.
	  4) Use the comparison	function comp to compare the values.

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 func-
       tion 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.

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) Exactly one comparison using operator<.
	  2) Exactly one application of	the comparison function	comp.
	  3,4) Given \(\scriptsize N\)N	as ilist.size():
	  3) Exactly \(\scriptsize N-1\)N-1 comparisons	using operator<.
	  4) Exactly \(\scriptsize N-1\)N-1  applications  of  the  comparison
       function	comp.

Possible implementation
				      min (1)
	  template<class T>
	  const	T& min(const T&	a, const T& b)
	  {
	      return (b	< a) ? b : a;
	  }
				      min (2)
	  template<class T, class Compare>
	  const	T& min(const T&	a, const T& b, Compare comp)
	  {
	      return (comp(b, a)) ? b :	a;
	  }
				      min (3)
	  template<class T>
	  T min(std::initializer_list<T> ilist)
	  {
	      return *std::min_element(ilist.begin(), ilist.end());
	  }
				      min (4)
	  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 + 2, n * 2); // r is dangling

Example
       // Run this code

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

	int main()
	{
	    std::cout << "smaller of 10	and 010	is " <<	std::min(10,  010)  <<
       '\n'
		      <<  "smaller  of 'd' and 'b' is '" << std::min('d', '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 10 and 010 is 8
	smaller	of 'd' and 'b' is 'b'
	shortest of "foo", "bar", and "hello" is "foo"

	  Defect reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	    DR	     Applied	to		   Behavior    as    published
       Correct behavior
	  LWG 281 C++98	      T	 was  required	to  be	CopyConstructible  for
       not required
			     overloads (1,2)

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		  2024.06.10			   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.1.quarterly>

home | help