std:: adjacent_find

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

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,2) o p ( * it, * ( it + 1 ) ) ! = false para (3,4) .

Si no se encuentran tales elementos, last es devuelto.

Complejidad

Dado result como el valor de retorno de adjacent_find , \(\scriptsize M\) M como std:: distance ( first, result ) y \(\scriptsize N\) N como std:: distance ( first, last ) :

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 una de las políticas estándar , std::terminate es llamado. Para cualquier otra ExecutionPolicy , el comportamiento está definido por la implementación.
• Si el algoritmo no puede asignar memoria, std::bad_alloc es lanzado.

Implementación posible

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

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 se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también