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

	  Returns the greater of the given values.

	  1-2) Returns the greater of a	and b.
	  3-4) Returns the greatest 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);
	  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
       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 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-2) Exactly one comparison
	  3-4) Exactly ilist.size() - 1	comparisons

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

Second version
	  template<class T, class Compare>
	  const	T& max(const T&	a, const T& b, Compare comp)
	  {
	      return (comp(a, b)) ? b :	a;
	  }
				   Third version
	  template< class T >
	  T max( std::initializer_list<T> ilist)
	  {
	      return *std::max_element(ilist.begin(), ilist.end());
	  }
				  Fourth version
	  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-1, n+1);
	// r is	dangling

Example
       // Run this code

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

	int main()
	{
	    std::cout << "larger of 1 and 9999 is " <<	std::max(1,  9999)  <<
       '\n'
		      <<  "larger  of 'a', and 'b' is '" << std::max('a', 'b')
       << "'\n"
		      << "largest of 1,	10, 50,	and 200	is "  <<  std::max({1,
       10, 50, 200}) <<	'\n'
		      << "longest of \"foo\", \"bar\", and \"hello\" is	\""
		      << std::max({ "foo", "bar", "hello" },
				  [](const    std::string_view	  s1,	 const
       std::string_view	s2) {
				      return s1.size() < s2.size();
				  }) <<	"\"\n";
	}

Output:
	larger of 1 and	9999 is	9999
	larger of 'a', and 'b' is 'b'
	largest	of 1, 10, 50, and 200 is 200
	longest	of "foo", "bar", and "hello" is	"hello"

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		  2022.07.31			   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.0>

home | help