Defined in header <algorithm>  

(1)  
template< class ForwardIt > ForwardIt min_element( ForwardIt first, ForwardIt last );  (until C++17)  
template< class ForwardIt > constexpr ForwardIt min_element( ForwardIt first, ForwardIt last );  (since C++17)  
template< class ExecutionPolicy, class ForwardIt > ForwardIt min_element( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last );  (2)  (since C++17) 
(3)  
template< class ForwardIt, class Compare > ForwardIt min_element( ForwardIt first, ForwardIt last, Compare comp );  (until C++17)  
template< class ForwardIt, class Compare > constexpr ForwardIt min_element( ForwardIt first, ForwardIt last, Compare comp );  (since C++17)  
template< class ExecutionPolicy, class ForwardIt, class Compare > ForwardIt min_element( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, Compare comp );  (4)  (since C++17) 
Finds the smallest element in the range [
first
,
last
)
.
operator<
.comp
.policy
. These overloads do not participate in overload resolution unless
 (until C++20) 
 (since C++20) 
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 a is less than b . The signature of the comparison function should be equivalent to the following:
While the signature does not need to have 
Type requirements  
ForwardIt must meet the requirements of LegacyForwardIterator. 
Iterator to the smallest element in the range [
first
,
last
)
. If several elements in the range are equivalent to the smallest element, returns the iterator to the first such element. Returns last
if the range is empty.
Exactly max(N1,0) comparisons, where N = std::distance(first, last)
.
The overloads with a template parameter named ExecutionPolicy
report errors as follows:
ExecutionPolicy
is one of the standard policies, std::terminate
is called. For any other ExecutionPolicy
, the behavior is implementationdefined. std::bad_alloc
is thrown. min_element (1) 

template<class ForwardIt> ForwardIt min_element(ForwardIt first, ForwardIt last) { if (first == last) return last; ForwardIt smallest = first; ++first; for (; first != last; ++first) if (*first < *smallest) smallest = first; return smallest; } 
min_element (3) 
template<class ForwardIt, class Compare> ForwardIt min_element(ForwardIt first, ForwardIt last, Compare comp) { if (first == last) return last; ForwardIt smallest = first; ++first; for (; first != last; ++first) if (comp(*first, *smallest)) smallest = first; return smallest; } 
#include <algorithm> #include <iostream> #include <vector> int main() { std::vector<int> v {3, 1, 4, 1, 5, 9}; std::vector<int>::iterator result = std::min_element(v.begin(), v.end()); std::cout << "min element has value " << *result << " and index [" << std::distance(v.begin(), result) << "]\n"; }
Output:
min element has value 4 and index [2]
The following behaviorchanging 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  returns last in this case 
returns the largest element in a range (function template) 

(C++11)  returns the smallest and the largest elements in a range (function template) 
returns the smaller of the given values (function template) 

(C++20)  returns the smallest element in a range (niebloid) 
© cppreference.com
Licensed under the Creative Commons AttributionShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/algorithm/min_element