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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::max_element	- std::max_element

Synopsis
	  Defined in header <algorithm>
	  template< class ForwardIt >
	  ForwardIt   max_element(  ForwardIt  first,			(until
       C++17)
	  ForwardIt last );
	  template< class ForwardIt >
	  constexpr  ForwardIt	max_element(  ForwardIt			(since
       C++17)
	  first, ForwardIt last	);
	  template< class ExecutionPolicy, class ForwardIt
	  >							  (2)	(since
       C++17)
	  ForwardIt max_element( ExecutionPolicy&& policy,
	  ForwardIt first, ForwardIt last );		   (1)
	  template< class ForwardIt, class Compare >
	  ForwardIt	     max_element(	    ForwardIt		first,
       (until C++17)
	  ForwardIt last, Compare comp );
	  template< class ForwardIt, class Compare >
	  constexpr    ForwardIt    max_element(    ForwardIt		   (3)
       (since C++17)
	  first, ForwardIt last, Compare comp );
	  template< class ExecutionPolicy, class
	  ForwardIt,   class   Compare	 >				   (4)
       (since C++17)
	  ForwardIt max_element( ExecutionPolicy&& policy,
	  ForwardIt first, ForwardIt last, Compare comp	);

	  Finds	the greatest element in	the range [first, last).

	  1) Elements are compared using operator<.
	  3)  Elements are compared using the given binary comparison function
       comp.
	  2,4) Same as (1,3), but executed according to	 policy.  These	 over-
       loads do	not
	  participate in overload resolution unless
	  std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>
	  (until C++20)
	  std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>
	  (since C++20)	is true.

Parameters
	  first, last -	forward	iterators defining the range to	examine
	  policy       - the execution policy to use. See execution policy for
       details.
			comparison function object (i.e. an object that	satis-
       fies the
			requirements of	Compare) which	returns	 true  if  the
       first argument
			is less	than the second.

			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 re-
       gardless	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
			ForwardIt can be dereferenced and then implicitly con-
       verted to both of
			them.

Type requirements
	  -
	  ForwardIt must meet the requirements of LegacyForwardIterator.

Return value
	  Iterator to the greatest element in the range	[first,	last). If sev-
       eral elements in
	  the range are	equivalent to the greatest element, returns the	itera-
       tor to the first
	  such element.	Returns	last if	the range is empty.

Complexity
	  Exactly  max(N-1,0)  comparisons,  where  N  =  std::distance(first,
       last).

Exceptions
	  The overloads	with a template	parameter named	ExecutionPolicy	report
       errors as
	  follows:

	    *  If  execution  of  a  function invoked as part of the algorithm
       throws an exception
	      and ExecutionPolicy is one of the	standard policies, std::termi-
       nate is called.
	      For any other ExecutionPolicy, the behavior  is  implementation-
       defined.
	    *  If  the	algorithm  fails to allocate memory, std::bad_alloc is
       thrown.

Possible implementation
First version
	  template<class ForwardIt>
	  ForwardIt max_element(ForwardIt first, ForwardIt last)
	  {
	      if (first	== last) return	last;

	      ForwardIt	largest	= first;
	      ++first;
	      for (; first != last; ++first) {
		  if (*largest < *first) {
		      largest =	first;
		  }
	      }
	      return largest;
	  }

Second version
	  template<class ForwardIt, class Compare>
	  ForwardIt max_element(ForwardIt first, ForwardIt last,
				Compare	comp)
	  {
	      if (first	== last) return	last;

	      ForwardIt	largest	= first;
	      ++first;
	      for (; first != last; ++first) {
		  if (comp(*largest, *first)) {
		      largest =	first;
		  }
	      }
	      return largest;
	  }

Example
       // Run this code

	#include <algorithm>
	#include <iostream>
	#include <vector>
	#include <cmath>

	static bool abs_compare(int a, int b)
	{
	    return (std::abs(a)	< std::abs(b));
	}

	int main()
	{
	    std::vector<int> v{	3, 1, -14, 1, 5, 9 };
	    std::vector<int>::iterator result;

	    result = std::max_element(v.begin(), v.end());
	    std::cout << "max element at: "  <<	 std::distance(v.begin(),  re-
       sult) <<	'\n';

	    result = std::max_element(v.begin(), v.end(), abs_compare);
	    std::cout  << "max element (absolute) at: "	<< std::distance(v.be-
       gin(), result) << '\n';
	}

Output:
	max element at:	5
	max element (absolute) at: 2

See also
	  min_element	      returns the smallest element in a	range
			      (function	template)
	  minmax_element      returns the smallest and the largest elements in
       a range
	  (C++11)	      (function	template)
	  max		      returns the greater of the given values
			      (function	template)
	  ranges::max_element returns the largest element in a range
	  (C++20)	      (niebloid)

http://cppreference.com		  2022.07.31		   std::max_element(3)

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

home | help