Espacios de nombres
Variantes
Acciones

std::adjacent_find

De cppreference.com
< cpp‎ | algorithm
 
 
Biblioteca de algoritmos
Políticas de ejecución (C++17)
Operaciones no modificadoras de secuencia
(C++11)(C++11)(C++11)
(C++17)
adjacent_find
Operaciones modificadoras de secuencia
Operaciones en almacenamiento no inicializado
Operaciones de partición
Operaciones de ordenación
(C++11)
Operaciones de búsqueda binaria
Operaciones de set (en rangos ordenados)
Operaciones de pila
(C++11)
Operaciones minimo/maximo
(C++11)
(C++17)
Permutaciones
Operaciones numéricas
Bibliotecas C
 
Definido en la cabecera <algorithm>
template< class ForwardIt >
ForwardIt adjacent_find( ForwardIt first, ForwardIt last );
(1)
template< class ForwardIt, BinaryPredicate p >
ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPredicate p );
(2)
Busca en la [first, last) rango por dos elementos idénticos consecutivos. La primera versión utiliza operator== para comparar los elementos, la segunda versión utiliza el predicado binario dado p .
Original:
Searches the range [first, last) for two consecutive identical elements. The first version uses operator== to compare the elements, the second version uses the given binary predicate p.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Contenido

[editar] Parámetros

first, last -
la gama de elementos a examinar
Original:
the range of elements to examine
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
p - binary predicate which returns ​true if the elements should be treated as equal.

The signature of the predicate function should be equivalent to the following:

 bool pred(const Type1 &a, const Type2 &b);

The signature does not need to have const &, but the function must not modify the objects passed to it.
The types Type1 and Type2 must be such that an object of type ForwardIt can be dereferenced and then implicitly converted to both of them.

Requerimientos de tipo
-
ForwardIt debe reunir los requerimientos de ForwardIterator.

[editar] Valor de retorno

un iterador a la primera de los elementos idénticos. Si no se encuentran tales elementos, last se devuelve
Original:
an iterator to the first of the identical elements. If no such elements are found, last is returned
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Complejidad

Exactamente las aplicaciones más pequeñas de (result - first) y ((last - 1) - first) del predicado donde result es el valor de retorno .
Original:
Exactly the smaller of (result - first) and ((last - 1) - first) applications of the predicate where result is the return value.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Posible implementación

Primera versió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;
}
Segunda versión
template<class ForwardIt, BinaryPredicate p>
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;
}

[editar] Ejemplo

El código siguiente se busca un par de enteros equivalentes en una serie de intergers .
Original:
The following code finds a pair of equivalent integers in an array of intergers.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

#include <algorithm>
#include <iostream>
 
int main()
{
    std::vector<int> v1{0, 1, 2, 3, 40, 40, 5};
 
    std::vector<int>::iterator result;
    result = std::adjacent_find(v1.begin(), v1.end());
 
    if (result == v1.end()) {
        std::cout << "no matching adjacent elements";
    } else {
        std::cout << "match at: " << std::distance(v1.begin(), result);
    }
}

Salida:

match at: 4

[editar] Ver también

removes consecutive duplicate elements in a range
(plantilla de función) [editar]