std::adjacent_find
| Definido en el encabezado <algorithm>
|
||
template< class ForwardIt >
ForwardIt adjacent_find( ForwardIt first, ForwardIt last );
|
(1) | (constexpr desde C++20) |
template< class ForwardIt, class BinaryPred >
ForwardIt adjacent_find( ForwardIt first, ForwardIt last,
BinaryPred p );
|
(2) | (constexpr desde C++20) |
template< class ExecutionPolicy, class ForwardIt >
ForwardIt adjacent_find( ExecutionPolicy&& policy,
ForwardIt first, ForwardIt last );
|
(3) | (desde C++17) |
template< class ExecutionPolicy, class ForwardIt, class BinaryPred >
ForwardIt adjacent_find( ExecutionPolicy&& policy,
ForwardIt first, ForwardIt last,
BinaryPred p );
|
(4) | (desde C++17) |
Busca en el rango fuente [first, last) el primer par de elementos adyacentes que satisfacen la condición especificada.
operator==.p.policy.true:
|
|
(hasta C++20) |
|
|
(desde C++20) |
Parámetros
| first, last | - | el par de iteradores que definen el rango |
| fuente p | - | predicado binario que devuelve true si los elementos deben ser tratados como iguales. La firma de la función predicado debe ser equivalente a la siguiente:
Si bien la firma no necesita tener |
| policy | - | la política de ejecución a utilizar |
| Requisitos de tipo | ||
-ForwardIt debe cumplir los requisitos de LegacyForwardIterator.
| ||
-BinaryPred debe cumplir los requisitos de BinaryPredicate.
| ||
Valor de retorno
El primer iterador iter en el rango fuente tal que la siguiente expresión se evalúa como true:
bool(*iter == *std::next(iter))bool(p(*iter, std::next(iter))Si no se encuentra tal iterador, se devuelve last.
Complejidad
Dado result como el valor de retorno de adjacent_find, M como std::distance(first, result) y N como std::distance(first, last):
operator==.p.operator==.p.Excepciones
- Si los recursos de memoria temporales requeridos para la paralelización no están disponibles, se lanza std::bad_alloc.
- Si se lanza una excepción no capturada al acceder a objetos a través de un argumento del algoritmo, el comportamiento está determinado por la política de ejecución (para políticas estándar, se invoca std::terminate).
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 (2) |
template<class ForwardIt, class BinaryPred>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last, BinaryPred 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 matching adjacent elements\n";
else
std::cout << "The first adjacent pair of equal elements is at "
<< 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 << "The entire vector is sorted in ascending order\n";
else
std::cout << "The last element in the non-decreasing subsequence is at "
<< std::distance(v1.begin(), i2) << ", *i2 = " << *i2 << '\n';
}
Salida:
The first adjacent pair of equal elements is at 4, *i1 = 40
The last element in the non-decreasing subsequence is at 7, *i2 = 41
Informes de defectos
Los siguientes informes de defectos que modifican el comportamiento fueron aplicados retroactivamente a los estándares C++ previamente publicados.
| DR | Aplicado a | Comportamiento publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 240 | C++98 | el requisito de complejidad no estaba claro | se aclaró |
Véase también
(C++20) |
encuentra los primeros dos elementos adyacentes que son iguales (o satisfacen un predicado dado) (objeto función de algoritmo) |
| elimina elementos duplicados consecutivos en un rango (plantilla de función & objeto función de algoritmo) | |
(C++20) |