std::min_element (3) - Linux Manuals

std::min_element: std::min_element

NAME

std::min_element - std::min_element

Synopsis

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

Finds the smallest 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 overloads do not participate in overload resolution unless std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> 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 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:
              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 ForwardIt can be dereferenced and then implicitly converted to both of them.

Type requirements

-
ForwardIt must meet the requirements of LegacyForwardIterator.

Return value

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.

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::terminate 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 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;
  }

Second version

  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;
  }

Example

// Run this code

  #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(std::begin(v), std::end(v));
      std::cout << "min element at: " << std::distance(std::begin(v), result);
  }

Output:

  min element at: 1