Partilhar via


adjacent_find

Procura dois elementos adjacentes que sejam iguais ou atendam a uma condição especificada.

template<class ForwardIterator>    ForwardIterator adjacent_find(       ForwardIterator _First,        ForwardIterator _Last    ); template<class ForwardIterator , class BinaryPredicate>    ForwardIterator adjacent_find(       ForwardIterator _First,        ForwardIterator _Last,        BinaryPredicate _Comp    );

Parâmetros

  • _First
    Um iterador de avanço que aborda a posição do primeiro elemento do intervalo a ser pesquisado.

  • _Last
    Um iterador de avanço que aborda a posição um após o elemento final do intervalo a ser pesquisado.

  • _Comp
    O predicado binário que fornece a condição a ser atendida pelos valores dos elementos adjacentes no intervalo pesquisado.

Valor de retorno

Um iterador de avanço para o primeiro elemento do par adjacente que são iguais entre si (na primeira versão) ou que satisfazem a condição fornecida pelo predicado binário (na segunda versão), desde que tal par de elementos seja encontrado. Caso contrário, um iterador apontando para _Last é retornado.

Comentários

O algoritmo adjacent_find é um algoritmo de sequência não modificável. O intervalo a ser pesquisado deve ser válido; todos os ponteiros devem ser desreferenciados dentro da sequência e a última posição deve ser acessível desde a primeira, por incrementação. A complexidade de tempo do algoritmo é linear no número de elementos contidos no intervalo.

O operator== usado para determinar a correspondência entre os elementos deve impor uma relação de equivalência entre seus operandos.

Exemplo

// alg_adj_fnd.cpp
// compile with: /EHsc
#include <list>
#include <algorithm>
#include <iostream>

// Returns whether second element is twice the first
bool twice (int elem1, int elem2 )
{
   return elem1 * 2 == elem2;
}

int main( ) 
{
   using namespace std;
   list <int> L;
   list <int>::iterator Iter;
   list <int>::iterator result1, result2;
   
   L.push_back( 50 );
   L.push_back( 40 );
   L.push_back( 10 );
   L.push_back( 20 );
   L.push_back( 20 );

   cout << "L = ( " ;
   for ( Iter = L.begin( ) ; Iter != L.end( ) ; Iter++ )
      cout << *Iter << " ";
   cout << ")" << endl;
   
   result1 = adjacent_find( L.begin( ), L.end( ) );
   if ( result1 == L.end( ) )
      cout << "There are not two adjacent elements that are equal."
           << endl;
   else
      cout << "There are two adjacent elements that are equal."
           << "\n They have a value of "
           <<  *( result1 ) << "." << endl;

   result2 = adjacent_find( L.begin( ), L.end( ), twice );
   if ( result2 == L.end( ) )
      cout << "There are not two adjacent elements where the "
           << " second is twice the first." << endl;
   else
      cout << "There are two adjacent elements where "
           << "the second is twice the first."
           << "\n They have values of " << *(result2++);
      cout << " & " << *result2 << "." << endl;
}
             

Requisitos

Cabeçalho: <algorithm>

Namespace: std

Consulte também

Referência

Versão sem Predicado de adjacent_find

Versão com Predicado de adjacent_find

Biblioteca de Modelos Padrão