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

NAME
     std::max - std::max

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

	Returns the greater of the given values.

	1,2) Returns the greater 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 greatest 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);
	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 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 greater of a and b. If they are equivalent, returns a.
	3,4)  The  greatest  value in ilist. If several values are equivalent to
     the greatest,
	returns the leftmost one.

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
				    max (1)
	template<class T>
	const T& max(const T& a, const T& b)
	{
	    return (a < b) ? b : a;
	}
				    max (2)
	template<class T, class Compare>
	const T& max(const T& a, const T& b, Compare comp)
	{
	    return (comp(a, b)) ? b : a;
	}
				    max (3)
	template<class T>
	T max(std::initializer_list<T> ilist)
	{
	    return *std::max_element(ilist.begin(), ilist.end());
	}
				    max (4)
	template<class T, class Compare>
	T max(std::initializer_list<T> ilist, Compare comp)
	{
	    return *std::max_element(ilist.begin(), ilist.end(), comp);
	}

Notes
	Capturing the result of std::max 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::max(n + 2, n * 2); // r is dangling

Example
     // Run this code

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

      int main()
      {
	  auto	longest  =  [](const std::string_view s1, const std::string_view
     s2)
			 {
			     return s1.size() < s2.size();
			 };

	  std::cout << "Larger of 69 and 96 is " << std::max(69, 96) << "\n"
		       "Larger of 'q' and 'p' is '"  <<  std::max('q',	'p')  <<
     "'\n"
		       "Largest of 010, 10, 0X10, and 0B10 is "
		    << std::max({010, 10, 0X10, 0B10}) << '\n'
		    << R"(Longest of "long", "short", and "int" is )"
		    <<	std::quoted(std::max({"long", "short", "int"}, longest))
     << '\n';
      }

Output:
      Larger of 69 and 96 is 96
      Larger of 'q' and 'p' is 'q'
      Largest of 010, 10, 0X10, and 0B10 is 16
      Longest of "long", "short", and "int" is "short"

	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
	min	    returns the smaller of the given values
		    (function template)
	minmax	    returns the smaller and larger of two elements
	(C++11)     (function template)
	max_element returns the largest element in a range
		    (function template)
	clamp	    clamps a value between a pair of boundary values
	(C++17)     (function template)
	ranges::max returns the greater of the given values
	(C++20)     (niebloid)

http://cppreference.com 	   2024.06.10			     std::max(3)
home | help