std::ranges:: min_element

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithm Function Objects (informell bekannt als Niebloids ), das heißt:

• Explizite Template-Argumentlisten können beim Aufruf keiner von ihnen angegeben werden.
• Keiner von ihnen ist sichtbar für argument-dependent lookup .
• Wenn einer von ihnen durch normal unqualified lookup als Name links vom Funktionsaufruf-Operator gefunden wird, wird argument-dependent lookup unterdrückt.

Parameter

Rückgabewert

Iterator zum kleinsten Element im Bereich [ first , last ) . Falls mehrere Elemente im Bereich dem kleinsten Element entsprechen, wird der Iterator zum ersten solchen Element zurückgegeben. Gibt den Iterator zurück, der gleich last ist, falls der Bereich leer ist (d.h., first == last ).

Komplexität

Genau max(N - 1, 0) Vergleiche, wobei N = ranges:: distance ( first, last ) .

Mögliche Implementierung

struct min_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 smallest = first;
        while (++first != last)
            if (std::invoke(comp, std::invoke(proj, *first), std::invoke(proj, *smallest)))
                smallest = first;
        return smallest;
    }
    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 min_element_fn min_element;

Beispiel

#include <algorithm>
#include <array>
#include <cmath>
#include <iostream>
int main()
{
    namespace ranges = std::ranges;
    std::array v{3, 1, -13, 1, 3, 7, -13};
    auto iterator = ranges::min_element(v.begin(), v.end());
    auto position = ranges::distance(v.begin(), iterator);
    std::cout << "min element is v[" << position << "] == " << *iterator << '\n';
    auto abs_compare = [](int a, int b) { return (std::abs(a) < std::abs(b)); };
    iterator = ranges::min_element(v, abs_compare);
    position = ranges::distance(v.begin(), iterator);
    std::cout << "|min| element is v[" << position << "] == " << *iterator << '\n';
}

min element is v[2] == -13
|min| element is v[1] == 1

Siehe auch