std::ranges::is_partitioned
De cppreference.com
<tbody>
</tbody>
| Definido en el archivo de encabezado <algorithm>
|
||
| Signatura de la llamada |
||
template< std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred > constexpr bool is_partitioned( I first, S last, Pred pred, Proj proj = {} ); |
(1) | (desde C++20) |
template< ranges::input_range R, class Proj = std::identity, std::indirect_unary_predicate< std::projected<ranges::iterator_t<R>, Proj>> Pred > constexpr bool is_partitioned( R&& r, Pred pred, Proj proj = {} ); |
(2) | (desde C++20) |
1) Devuelve
true si todos los elementos del rango [first, last) que satisfacen el predicado pred después de la proyección aparecen antes de todos los elementos que no lo satisfacen. También devuelve true si [first, last) está vacío.2) Igual que (1), pero utiliza
r como rango de origen, como si se utilizara ranges::begin(r) como first y ranges::end(r) como last.Las entidades similares a funciones descritas en esta página son niebloids, es decir:
- Las listas de argumentos de plantilla explícitas no se pueden especificar al llamar a cualquiera de ellas.
- Ninguna de ellas es visible para la búsqueda dependiente de argumentos.
- Cuando alguna de ellas se encuentra mediante la búsqueda normal no calificada como el nombre a la izquierda del operador de llamada a función, se inhibe la búsqueda dependiente de argumentos.
En la práctica, pueden implementarse como objetos función o con extensiones de compilador especiales.
Parámetros
| first, last | - | Par iterador-centinela que denota el rango de elementos a examinar. |
| r | - | El rango de elementos a examinar. |
| pred | - | El predicado que se aplicará a los elementos proyectados. |
| proj | - | La proyección que se aplicará a los elementos |
Valor de retorno
true si el rango [first, last) está vacío o está particionado por pred, false en caso contrario.
Complejidad
Como máximo ranges::distance(first, last) aplicaciones de pred y proj.
Posible implementación
struct is_partitioned_fn
{
template<std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity,
std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
constexpr bool operator()(I first, S last, Pred pred, Proj proj = {}) const
{
for (; first != last; ++first)
if (!std::invoke(pred, std::invoke(proj, *first)))
break;
for (; first != last; ++first)
if (std::invoke(pred, std::invoke(proj, *first)))
return false;
return true;
}
template<ranges::input_range R, class Proj = std::identity,
std::indirect_unary_predicate<std::projected<ranges::iterator_t<R>, Proj>> Pred>
constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const
{
return (*this)(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
}
};
inline constexpr auto is_partitioned = is_partitioned_fn();
|
Ejemplo
Ejecuta este código
#include <algorithm>
#include <array>
#include <iostream>
#include <numeric>
#include <utility>
int main()
{
std::array<int, 9> v;
auto imprimir = [&v](bool o)
{
for (int x : v)
std::cout << x << ' ';
std::cout << (o ? "=> " : "=> no ") << "particionado\n";
};
auto es_par = [](int i) { return i % 2 == 0; };
std::iota(v.begin(), v.end(), 1); // or std::ranges::iota(v, 1);
imprimir(std::ranges::is_partitioned(v, es_par));
std::ranges::partition(v, es_par);
imprimir(std::ranges::is_partitioned(std::as_const(v), es_par));
std::ranges::reverse(v);
imprimir(std::ranges::is_partitioned(v.cbegin(), v.cend(), es_par));
imprimir(std::ranges::is_partitioned(v.crbegin(), v.crend(), es_par));
}
Salida:
1 2 3 4 5 6 7 8 9 => no particionado
2 4 6 8 5 3 7 1 9 => particionado
9 1 7 3 5 8 6 4 2 => no particionado
9 1 7 3 5 8 6 4 2 => particionado
Véase también
(C++20) |
Divide un rango de elementos en dos grupos (niebloid) |
(C++20) |
Localiza el punto de partición de un rango particionado (niebloid) |
(C++11) |
Determina si el rango está particionado por el predicado dado. (plantilla de función) |