Std::min_element (3) Linux Manual Page

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

std::min_element (3) Linux Manual Page