std:: max_element
| 
           Defined in header
            
            
             <algorithm>
            
            | ||
| 
           
           
           
            
             template
            
            
             <
            
            
             class
            
            ForwardIt
            
             >
            
             ForwardIt max_element ( ForwardIt first, ForwardIt last ) ; | (1) | (constexpr since C++17) | 
| 
           
            
             template
            
            
             <
            
            
             class
            
            ExecutionPolicy,
            
             class
            
            ForwardIt
            
             >
            
             
             ForwardIt max_element
             
              (
             
             ExecutionPolicy
             
              &&
             
             policy,
              | (2) | (since C++17) | 
| 
           
           
           
            
             template
            
            
             <
            
            
             class
            
            ForwardIt,
            
             class
            
            Compare
            
             >
            
             
             ForwardIt max_element
             
              (
             
             ForwardIt first, ForwardIt last,
              | (3) | (constexpr since C++17) | 
| 
           
            
             template
            
            
             <
            
            
             class
            
            ExecutionPolicy,
            
             class
            
            ForwardIt,
            
             class
            
            Compare
            
             >
            
             
             ForwardIt max_element
             
              (
             
             ExecutionPolicy
             
              &&
             
             policy,
              | (4) | (since C++17) | 
       Finds the greatest element in the range
       
        
         [
        
        
         
          first
         
        
        
         ,
        
        
         
          last
         
        
        
         )
        
       
       .
      
| std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> is true . | (until C++20) | 
| std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> is true . | (since C++20) | 
Parameters
| first, last | - | forward iterators defining the range to examine | 
| policy | - | the execution policy to use. See execution policy for details. | 
| comp | - | comparison function object (i.e. an object that satisfies 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 ) ; 
          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)
           | 
| Type requirements | ||
| - 
          ForwardIt
         must meet the requirements of
         
          
           LegacyForwardIterator
          
         
         . | ||
Return value
       Iterator to the greatest element in the range
       
        
         [
        
        
         
          first
         
        
        
         ,
        
        
         
          last
         
        
        
         )
        
       
       . If several elements in the range are equivalent to the greatest element, returns the iterator to the first such element. Returns
       
        
         last
        
       
       if the range is empty.
      
Complexity
Given N as 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
        ExecutionPolicyis one of the standard policies , std::terminate is called. For any otherExecutionPolicy, the behavior is implementation-defined.
- If the algorithm fails to allocate memory, std::bad_alloc is thrown.
Possible implementation
| max_element (1) | 
|---|
| template<class ForwardIt> ForwardIt max_element(ForwardIt first, ForwardIt last) { if (first == last) return last; ForwardIt largest = first; while (++first != last) if (*largest < *first) largest = first; return largest; } | 
| max_element (3) | 
| template<class ForwardIt, class Compare> ForwardIt max_element(ForwardIt first, ForwardIt last, Compare comp) { if (first == last) return last; ForwardIt largest = first; while(++first != last) if (comp(*largest, *first)) largest = first; return largest; } | 
Example
#include <algorithm> #include <cmath> #include <iostream> #include <vector> int main() { std::vector<int> v{3, 1, -14, 1, 5, 9, -14, 9}; std::vector<int>::iterator result; result = std::max_element(v.begin(), v.end()); std::cout << "Max element found at index " << std::distance(v.begin(), result) << " has value " << *result << '\n'; result = std::max_element(v.begin(), v.end(), [](int a, int b) { return std::abs(a) < std::abs(b); }); std::cout << "Absolute max element found at index " << std::distance(v.begin(), result) << " has value " << *result << '\n'; }
Output:
Max element found at index 5 has value 9 Absolute max element found at index 2 has value -14
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior | 
|---|---|---|---|
| LWG 212 | C++98 | the return value was not specified if 
           [
          first
           ,
          last
           )
          is empty | returns last in this case | 
| LWG 2150 | C++98 | the iterator to the first non-smallest element was returned | corrected the return value | 
See also
| returns the smallest element in a range (function template) | |
| 
           
            
             
              (C++11)
             
            
           
           | returns the smallest and the largest elements in a range (function template) | 
| returns the greater of the given values (function template) | |
| 
           
            
             
              (C++20)
             
            
           
           | returns the largest element in a range (algorithm function object) |