Namespaces
Variants

std:: is_sorted_until

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
(C++11)
is_sorted_until
(C++11)

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
Definido en el encabezado <algorithm>
template < class ForwardIt >
ForwardIt is_sorted_until ( ForwardIt first, ForwardIt last ) ;
(1) (desde C++11)
(constexpr desde C++20)
template < class ExecutionPolicy, class ForwardIt >

ForwardIt is_sorted_until ( ExecutionPolicy && policy,

ForwardIt first, ForwardIt last ) ;
(2) (desde C++17)
template < class ForwardIt, class Compare >

ForwardIt is_sorted_until ( ForwardIt first, ForwardIt last,

Compare comp ) ;
(3) (desde C++11)
(constexpr desde C++20)
template < class ExecutionPolicy, class ForwardIt, class Compare >

ForwardIt is_sorted_until ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,

Compare comp ) ;
(4) (desde C++17)

Examina el rango [ first , last ) y encuentra el rango más grande que comienza en first en el cual los elementos están ordenados en orden no decreciente.

1) Encuentra el rango más grande donde los elementos están ordenados con respecto a operator < (until C++20) std:: less { } (since C++20) .
3) Encuentra el rango más grande donde los elementos están ordenados con respecto a comp .
2,4) Igual que (1,3) , pero ejecutado de acuerdo con la policy .
Estas sobrecargas participan en la resolución de sobrecarga solo si se satisfacen todas las siguientes condiciones:

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> es true .

(hasta C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> es true .

(desde C++20)

Contenidos

Parámetros

first, last - el par de iteradores que define el rango de elementos a examinar
policy - la política de ejecución a utilizar
comp - objeto función de comparación (es decir, un objeto que satisface los requisitos de Compare ) que devuelve ​ true si el primer argumento es menor que (es decir, está ordenado antes que) el segundo.

La firma de la función de comparación debe ser equivalente a la siguiente:

bool cmp ( const Type1 & a, const Type2 & b ) ;

Aunque la firma no necesita tener const & , la función no debe modificar los objetos pasados a ella y debe poder aceptar todos los valores de tipo (posiblemente const) Type1 y Type2 independientemente de la categoría de valor (por lo tanto, Type1& no está permitido , ni tampoco Type1 a menos que para Type1 un movimiento sea equivalente a una copia (since C++11) ).
Los tipos Type1 y Type2 deben ser tales que un objeto de tipo ForwardIt pueda ser desreferenciado y luego convertido implícitamente a ambos. ​

Requisitos de tipo
-
ForwardIt debe cumplir con los requisitos de LegacyForwardIterator .
-
Compare debe cumplir con los requisitos de Compare .

Valor de retorno

El límite superior del rango más grande que comienza en first en el cual los elementos están ordenados en orden ascendente. Es decir, el último iterador it para el cual el rango [ first , it ) está ordenado.

Devuelve last para rangos vacíos y rangos de longitud uno.

Complejidad

Dado N como std:: distance ( first, last ) :

1,2) O(N) comparaciones usando operator < (hasta C++20) std:: less { } (desde C++20) .
3,4) O(N) aplicaciones del comparador comp .

Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy reportan errores de la siguiente manera:

  • Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es uno de los standard policies , std::terminate es llamado. Para cualquier otro ExecutionPolicy , el comportamiento está definido por la implementación.
  • Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Implementación posible

Consulte también las implementaciones en libstdc++ y libc++ .

is_sorted_until (1) 
template<class ForwardIt>
constexpr //< since C++20
ForwardIt is_sorted_until(ForwardIt first, ForwardIt last)
{
    return std::is_sorted_until(first, last, std::less<>());
}
is_sorted_until (2) 
template<class ForwardIt, class Compare>
constexpr //< since C++20
ForwardIt is_sorted_until(ForwardIt first, ForwardIt last, Compare comp)
{
    if (first != last)
    {
        ForwardIt next = first;
        while (++next != last)
        {
            if (comp(*next, *first))
                return next;
            first = next;
        }
    }
    return last;
}

Ejemplo

Ejecutar este código 
#include <algorithm>
#include <cassert>
#include <iostream>
#include <iterator>
#include <random>
#include <string>
int main()
{
    std::random_device rd;
    std::mt19937 g(rd());
    const int N = 6;
    int nums[N] = {3, 1, 4, 1, 5, 9};
    const int min_sorted_size = 4;
    for (int sorted_size = 0; sorted_size < min_sorted_size;)
    {
        std::shuffle(nums, nums + N, g);
        int *const sorted_end = std::is_sorted_until(nums, nums + N);
        sorted_size = std::distance(nums, sorted_end);
        assert(sorted_size >= 1);
        for (const auto i : nums)
            std::cout << i << ' ';
        std::cout << ": " << sorted_size << " elementos ordenados iniciales\n"
                  << std::string(sorted_size * 2 - 1, '^') << '\n';
    }
}

Posible salida: 

4 1 9 5 1 3 : 1 elementos ordenados iniciales
^
4 5 9 3 1 1 : 3 elementos ordenados iniciales
^^^^^
9 3 1 4 5 1 : 1 elementos ordenados iniciales
^
1 3 5 4 1 9 : 3 elementos ordenados iniciales
^^^^^
5 9 1 1 3 4 : 2 elementos ordenados iniciales
^^^
4 9 1 5 1 3 : 2 elementos ordenados iniciales
^^^
1 1 4 9 5 3 : 4 elementos ordenados iniciales
^^^^^^^

Véase también

(C++11)
verifica si un rango está ordenado en orden ascendente
(plantilla de función)
(C++20)
encuentra el subrango ordenado más grande
(objeto función de algoritmo)