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

FreeBSD Manual Pages

  
 
  

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) (const-
       expr since C++14)
	  const	T& max(	const T& a, const T& b );
	  template< class T, class Compare >			  (2)  (const-
       expr 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	 );		       (const-
       expr since C++14)
	  template<  class  T,	class Compare >			    (4)	(since
       C++11)
	  T max( std::initializer_list<T> ilist, Compare comp  );      (const-
       expr 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  equiva-
       lent to the
		  following:

		  bool cmp(const Type1&	a, const Type2&	b);
	  comp	-
		  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 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
       function	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
       reference 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
       Correct 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)

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

home | help