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) (constexpr
     since C++14)
	const T& min( const T& a, const T& b );
	template< class T, class Compare  >			 (2)  (constexpr
     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 );		      (constexpr
     since C++14)
	template< class T, class Compare >		       (4) (since C++11)
	T min( std::initializer_list<T> ilist, Compare	comp  );      (constexpr
     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 equivalent 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 cate-
     gory (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  func-
     tion 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 refer-
     ence 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		    Cor-
     rect 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)
home | help