std::adjacent_find - cppreference.com

</tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody>

Busca en el rango [first, last) por dos elementos consecutivos iguales.

1) Los elementos se comparan usando operator==.

3) Los elementos se comparan usando el predicado binario dado p.

2,4) Igual que (1,3), pero se ejecuta de acuerdo a la política de ejecución 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

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

1,3) Exactamente std::min((result - first) + 1, (last - first) - 1) aplicaciones del predicado, donde result es el valor de retorno.

2,4) 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

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;
}

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';
}

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.

Véase también