std::adjacent_find
| Definido en el archivo de encabezado <algorithm>
|
||
| (1) | ||
template< class ForwardIt > ForwardIt adjacent_find( ForwardIt first, ForwardIt last ); |
(hasta C++20) | |
template< class ForwardIt > constexpr ForwardIt adjacent_find( ForwardIt first, ForwardIt last ); |
(desde C++20) | |
template< class ExecutionPolicy, class ForwardIt > ForwardIt adjacent_find( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last ); |
(2) | (desde C++17) |
| (3) | ||
template< class ForwardIt, class BinaryPredicate > ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPredicate p ); |
(hasta C++20) | |
template< class ForwardIt, class BinaryPredicate > constexpr ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPredicate p ); |
(desde C++20) | |
template< class ExecutionPolicy, class ForwardIt, class BinaryPredicate > ForwardIt adjacent_find( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, BinaryPredicate p ); |
(4) | (desde C++17) |
Busca en el rango [first, last) por dos elementos consecutivos iguales.
operator==.p.policy. Estas sobrecargas no participan en la resolución de sobrecarga a menos que std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (hasta C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (desde C++20) sea verdadera.Parámetros
| first, last | - | El rango de los elementos a examinar. |
| policy | - | La política de ejecución a usar. Véase política de ejecución para más detalles. |
| p | - | Predicado binario que devuelve true si los elementos deben tratarse como iguales. La signatura de la función predicado deberá ser equivalente a la siguiente:
Mientras que la signatura no necesita tener |
| Requisitos de tipo | ||
-ForwardIt debe satisfacer los requisitos de ForwardIterator.
| ||
Valor de retorno
Un iterador al primero del primer par de elementos idénticos, es decir, el primer iterador it tal que *it == *(it + 1) para (1,3) o p(*it, *(it + 1)) != false para (2,4).
Si no se encuentran dichos elementos, se devuelve last.
Complejidad
std::min((result - first) + 1, (last - first) - 1) aplicaciones del predicado, donde result es el valor de retorno.O(last - first) aplicaciones del predicado correspondiente.Excepciones
Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reportan errores tales que:
- Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la política de ejecución es una de las tres políticas estándar, se llama a std::terminate. Para cualquier otra política de ejecución, el comportamiento está definido por la implementación.
- Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.
Posible implementación
| adjacent_find (1) |
|---|
template<class ForwardIt>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last)
{
if (first == last)
return last;
ForwardIt next = first;
++next;
for (; next != last; ++next, ++first)
if (*first == *next)
return first;
return last;
}
|
| adjacent_find (3) |
template<class ForwardIt, class BinaryPredicate>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last, BinaryPredicate p)
{
if (first == last)
return last;
ForwardIt next = first;
++next;
for (; next != last; ++next, ++first)
if (p(*first, *next))
return first;
return last;
}
|
Ejemplo
#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v1 {0, 1, 2, 3, 40, 40, 41, 41, 5};
auto i1 = std::adjacent_find(v1.begin(), v1.end());
if (i1 == v1.end())
std::cout << "No se encuentran elementos adyacentes coincidentes\n";
else
std::cout << "El primer par de elementos adyacentes iguales se encuentra en "
<< std::distance(v1.begin(), i1) << ", *i1 = "
<< *i1 << '\n';
auto i2 = std::adjacent_find(v1.begin(), v1.end(), std::greater<int>());
if (i2 == v1.end())
std::cout << "Todo el vector está ordernado en orden ascendente\n";
else
std::cout << "El último elemento en una subsecuencia no decreciente se encuentra en "
<< std::distance(v1.begin(), i2) << ", *i2 = " << *i2 << '\n';
}
Salida:
El primer par de elementos adyacentes iguales se encuentra en 4, *i1 = 40
El último elemento en una subsecuencia no decreciente se encuentra en 7, *i2 = 41
Informes de defectos
Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.
| ID | Aplicado a | Comportamiento según lo publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 240 | C++98 | El predicado estaba aplicado std::find(first, last, value) - first vecespara (1,3), donde value nunca se definió.
|
Se aplica std::min((result - first) + 1,(last - first) - 1) veces.
|
Véase también
| Elimina elementos duplicados consecutivos en un rango. (plantilla de función) | |
(C++20) |
Encuentra dos primeros elementos contiguos idénticos (o que satisfagan un predicado dado). (niebloid) |
