Namespaces
Variants

std::ranges:: min

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Constrained algorithms
All names in this menu belong to namespace std::ranges
Non-modifying sequence operations
Modifying sequence operations
Partitioning operations
Sorting operations
Binary search operations (on sorted ranges)
Set operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Permutation operations
Fold operations
Operations on uninitialized storage
Return types
**Erläuterungen zur Übersetzung:** - HTML-Tags und Attribute wurden unverändert belassen - C++-spezifische Begriffe (template, class, constexpr, const, etc.) wurden nicht übersetzt - Code-Blöcke innerhalb der ` ` wurden nicht übersetzt - Nur der beschreibende Text "(since C++20)" wurde zu "(seit C++20)" übersetzt - Die Formatierung und Struktur der HTML-Elemente wurde vollständig beibehalten (Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur wurde gemäß den Anforderungen unverändert beibehalten.)
Definiert in Header <algorithm>
Aufrufsignatur
template < class T, class Proj = std:: identity ,

std:: indirect_strict_weak_order <
std :: projected < const T * , Proj >> Comp = ranges:: less >
constexpr const T &

min ( const T & a, const T & b, Comp comp = { } , Proj proj = { } ) ;
(1) (seit C++20)
template < std:: copyable T, class Proj = std:: identity ,

std:: indirect_strict_weak_order <
std :: projected < const T * , Proj >> Comp = ranges:: less >
constexpr T

min ( std:: initializer_list < T > r, Comp comp = { } , Proj proj = { } ) ;
(2) (seit C++20)
template < ranges:: input_range R, class Proj = std:: identity ,

std:: indirect_strict_weak_order <
std :: projected < ranges:: iterator_t < R > , Proj >> Comp = ranges:: less >
erfordert std:: indirectly_copyable_storable < ranges:: iterator_t < R > ,
ranges:: range_value_t < R > * >
constexpr ranges:: range_value_t < R >

min ( R && r, Comp comp = { } , Proj proj = { } ) ;
(3) (seit C++20)

Gibt das kleinere der gegebenen projizierten Elemente zurück.

1) Gibt den kleineren Wert von a und b zurück.
2) Gibt das erste kleinste Element in der Initialisierungsliste r zurück.
3) Gibt den ersten kleinsten Wert im Bereich r zurück.

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

Inhaltsverzeichnis

Parameter

a, b - die zu vergleichenden Werte
r - der Bereich der zu vergleichenden Werte
comp - Vergleich, der auf die projizierten Elemente angewendet wird
proj - Projektion, die auf die Elemente angewendet wird

Rückgabewert

1) Der kleinere Wert von a und b gemäß der Projektion. Falls sie äquivalent sind, wird a zurückgegeben.
2,3) Das kleinste Element in r , gemäß der Projektion. Wenn mehrere Werte dem kleinsten entsprechen, wird der am weitesten links stehende zurückgegeben. Wenn der Bereich leer ist (wie durch ranges:: distance ( r ) bestimmt), ist das Verhalten undefiniert.

Komplexität

1) Genau ein Vergleich.
2,3) Genau ranges:: distance ( r ) - 1 Vergleiche.

Mögliche Implementierung 

struct min_fn
{
    template<class T, class Proj = std::identity,
             std::indirect_strict_weak_order<
                 std::projected<const T*, Proj>> Comp = ranges::less>
    constexpr
    const T& operator()(const T& a, const T& b, Comp comp = {}, Proj proj = {}) const
    {
        return std::invoke(comp, std::invoke(proj, b), std::invoke(proj, a)) ? b : a;
    }
    template<std::copyable T, class Proj = std::identity,
             std::indirect_strict_weak_order<
                 std::projected<const T*, Proj>> Comp = ranges::less>
    constexpr
    T operator()(std::initializer_list<T> r, Comp comp = {}, Proj proj = {}) const
    {
        return *ranges::min_element(r, std::ref(comp), std::ref(proj));
    }
    template<ranges::input_range R, class Proj = std::identity,
             std::indirect_strict_weak_order<
                  std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less>
    requires std::indirectly_copyable_storable<ranges::iterator_t<R>,
                                               ranges::range_value_t<R>*>
    constexpr
    ranges::range_value_t<R> operator()(R&& r, Comp comp = {}, Proj proj = {}) const
    {
        using V = ranges::range_value_t<R>;
        if constexpr (ranges::forward_range<R>)
            return
                static_cast<V>(*ranges::min_element(r, std::ref(comp), std::ref(proj)));
        else
        {
            auto i = ranges::begin(r);
            auto s = ranges::end(r);
            V m(*i);
            while (++i != s)
                if (std::invoke(comp, std::invoke(proj, *i), std::invoke(proj, m)))
                    m = *i;
            return m;
        }
    }
};
inline constexpr min_fn min;

Hinweise

Das Erfassen des Ergebnisses von std::ranges::min per Referenz erzeugt eine hängende Referenz, wenn einer der Parameter ein temporäres Objekt ist und dieser Parameter zurückgegeben wird: 

int n = -1;
const int& r = std::ranges::min(n + 2, n * 2); // r ist hängend

Beispiel

Diesen Code ausführen 
#include <algorithm>
#include <iostream>
#include <string>
int main()
{
    namespace ranges = std::ranges;
    using namespace std::string_view_literals;
    std::cout << "smaller of 1 and 9999: " << ranges::min(1, 9999) << '\n'
              << "smaller of 'a', and 'b': '" << ranges::min('a', 'b') << "'\n"
              << "shortest of \"foo\", \"bar\", and \"hello\": \""
              << ranges::min({"foo"sv, "bar"sv, "hello"sv}, {},
                             &std::string_view::size) << "\"\n";
}

Ausgabe: 

smaller of 1 and 9999: 1
smaller of 'a', and 'b': 'a'
shortest of "foo", "bar", and "hello": "foo"

Siehe auch

(C++20)
gibt den größeren der gegebenen Werte zurück
(Algorithmus-Funktionsobjekt)
(C++20)
gibt den kleineren und größeren von zwei Elementen zurück
(Algorithmus-Funktionsobjekt)
(C++20)
gibt das kleinste Element in einem Bereich zurück
(Algorithmus-Funktionsobjekt)
(C++20)
begrenzt einen Wert zwischen einem Paar von Grenzwerten
(Algorithmus-Funktionsobjekt)
gibt den kleineren der gegebenen Werte zurück
(Funktionstemplate)