adjacent_find

Articolo
03/26/2013

Cerca due elementi adiacenti che sono uguali o soddisfano una condizione specificata.

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

Parametri

_First
Un iteratore avanti destinato alla posizione del primo elemento nell'intervallo da rilevare.
_Last
Un iteratore avanti destinato alla posizione una dopo l'elemento finale nell'intervallo da rilevare.
_Comp
Il predicato binario che fornisce la condizione soddisfatta dai valori degli elementi adiacenti nell'intervallo trovato.

Valore restituito

Un iteratore nel primo elemento della coppia adiacenti che viene loro uguale (nella prima versione) o che soddisfa la condizione fornita dal predicato binario (nella seconda versione), a condizione che tale coppia di elementi viene trovata.In caso contrario, un iteratore che punta a _Last viene restituito.

Note

l'algoritmo adjacent_find è un algoritmo nonmutating di sequenza.Intervallo da rilevare deve essere valido; tutti i puntatori devono essere dereferenceable e l'ultima posizione è raggiungibile da prima dall'aumento.La complessità di tempo dell'algoritmo è lineare il numero di elementi contenuti nell'intervallo.

operator== utilizzato per determinare la corrispondenza tra elementi necessario imporre una relazione di equivalenza fra i propri operandi.

Esempio

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

Requisiti

intestazione: <algorithm>

Spazio dei nomi: deviazione standard

Vedere anche

Riferimenti

Nonpredicate Version of adjacent_find

Predicate Version of adjacent_find

Libreria di modelli standard

Condividi tramite