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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::ranges::max_element	- std::ranges::max_element

Synopsis
	  Defined in header <algorithm>
	  Call signature
	  template<  std::forward_iterator  I,	std::sentinel_for<I>  S, class
       Proj =
	  std::identity,

	  std::indirect_strict_weak_order<std::projected<I,  Proj>>   Comp   =
       (1) (since
	  ranges::less							     >
       C++20)

	  constexpr I max_element( I first, S last, Comp comp =	{}, Proj  proj
       = {}
	  );
	  template< ranges::forward_range R, class Proj	= std::identity,

	  std::indirect_strict_weak_order<
       (since
	  std::projected<ranges::iterator_t<R>,	 Proj>>	 Comp =	ranges::less >
       (2) C++20)
	  constexpr ranges::borrowed_iterator_t<R>

	  max_element( R&& r, Comp comp	= {}, Proj proj	= {} );

	  1) Finds the greatest	element	in the range [first, last).
	  2) Same as (1), but  uses  r	as  the	 source	 range,	 as  if	 using
       ranges::begin(r)	as
	  first	and ranges::end(r) as last.

	  The  function-like  entities	described  on this page	are niebloids,
       that is:

	    * Explicit template	argument lists may not be specified when call-
       ing any of them.
	    * None of them is visible to argument-dependent lookup.
	    * When one of them is found	by normal unqualified lookup  for  the
       name to the left
	      of  the  function-call  operator,	it inhibits argument-dependent
       lookup.

	  In practice, they may	be implemented as function  objects,  or  with
       special compiler
	  extensions.

Parameters
	  first, last -	iterator-sentinel pair denoting	the range to examine
	  r	      -	the range to examine
	  comp	      -	comparison to apply to the projected elements
	  proj	      -	projection to apply to the elements

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	first if the range is empty.

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

Possible implementation
	 struct	max_element_fn {
	   template<std::forward_iterator  I,  std::sentinel_for<I>  S,	 class
       Proj = std::identity,
		    std::indirect_strict_weak_order<std::projected<I,	Proj>>
       Comp = ranges::less>
	   constexpr I operator()(I first, S last, Comp	comp = {}, Proj	proj =
       {}) const
	   {
	     if	(first == last)	{
	       return last;
	     }

	     auto largest = first;
	     ++first;
	     for (; first != last; ++first) {
		 if (std::invoke(comp, std::invoke(proj,  *largest),  std::in-
       voke(proj, *first))) {
		     largest = first;
		 }
	     }
	     return largest;
	   }

	   template<ranges::forward_range R, class Proj	= std::identity,
		    std::indirect_strict_weak_order<
			std::projected<ranges::iterator_t<R>,  Proj>>  Comp  =
       ranges::less>
	   constexpr ranges::borrowed_iterator_t<R>
	   operator()(R&& r, Comp comp = {}, Proj proj = {}) const
	   {
	     return (*this)(ranges::begin(r), ranges::end(r),  std::ref(comp),
       std::ref(proj));
	   }
	 };

	 inline	constexpr max_element_fn max_element;

Example
       // Run this code

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

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

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

	    auto  abs_compare  =  [](int  a,  int  b)  { return	(std::abs(a) <
       std::abs(b)); };
	    result = ranges::max_element(v, abs_compare);
	    std::cout  <<  "max	 element  (absolute)  at:  "  <<  ranges::dis-
       tance(v.begin(),	result)	<< '\n';
	}

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

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

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

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

home | help