std::ranges::is_sorted

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 bool
    is_sorted( I first, S last, Comp comp = {}, Proj proj = {} );

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 bool
    is_sorted( R&& r, Comp comp = {}, Proj proj = {} );

Überprüft, ob die Elemente im Bereich [first, last) in nicht‑absteigender Reihenfolge sortiert sind.

Eine Sequenz ist bezüglich eines Vergleichs comp sortiert, wenn für jeden Iterator it, der auf die Sequenz zeigt, und jede nicht‑negative ganze Zahl n, so dass it + n ein gültiger Iterator ist, der auf ein Element der Sequenz zeigt, std::invoke(comp, std::invoke(proj, *(it + n)), std::invoke(proj, *it)) zu false ausgewertet wird.

Die auf dieser Seite beschriebenen funktionsartigen Entitäten sind Algorithmus‑Funktionsobjekte (informell als Niebloide bekannt), das heißt:

• Explizite Template‑Argumentlisten können beim Aufruf keiner von ihnen angegeben werden.
• Keine von ihnen ist für die argumentabhängige Suche sichtbar.
• Wenn eine von ihnen durch normale unqualifizierte Suche als Name links vom Funktionsaufrufoperator gefunden wird, wird argumentabhängige Suche unterdrückt.

Parameter

Rückgabewert

true wenn die Elemente im Bereich gemäß comp sortiert sind.

Komplexität

Linear in der Entfernung zwischen first und last .

Mögliche Implementierung

struct is_sorted_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 bool operator()(I first, S last, Comp comp = {}, Proj proj = {}) const
    {
        return ranges::is_sorted_until(first, last, comp, proj) == last;
    }
    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 bool operator()(R&& r, Comp comp = {}, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::ref(comp), std::ref(proj));
    }
};
inline constexpr is_sorted_fn is_sorted;

Hinweise

ranges::is_sorted gibt true für leere Bereiche und Bereiche der Länge eins zurück.

Beispiel

#include <algorithm>
#include <array>
#include <functional>
#include <iostream>
#include <iterator>
int main()
{
    namespace ranges = std::ranges;
    std::array digits {3, 1, 4, 1, 5};
    ranges::copy(digits, std::ostream_iterator<int>(std::cout, " "));
    ranges::is_sorted(digits)
        ? std::cout << ": sortiert\n"
        : std::cout << ": nicht sortiert\n";
    ranges::sort(digits);
    ranges::copy(digits, std::ostream_iterator<int>(std::cout, " "));
    ranges::is_sorted(ranges::begin(digits), ranges::end(digits))
        ? std::cout << ": sortiert\n"
        : std::cout << ": nicht sortiert\n";
    ranges::reverse(digits);
    ranges::copy(digits, std::ostream_iterator<int>(std::cout, " "));
    ranges::is_sorted(digits, ranges::greater {})
        ? std::cout << ": sortiert (mit 'greater')\n"
        : std::cout << ": nicht sortiert\n";
}

3 1 4 1 5 : nicht sortiert
1 1 3 4 5 : sortiert
5 4 3 1 1 : sortiert (mit 'greater')

Siehe auch