zpr c++ quick reference

Ta strona jest tylko do odczytu. Możesz wyświetlić źródła tej strony ale nie możesz ich zmienić.
====== Algorytm adjacent_find() ======

<code cpp>
template <class ForwardIterator> 
  ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last);

template <class ForwardIterator, class BinaryPredicate> 
  ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred);
</code>

Algorytm zawarty w Standard Template Library. 
Funkcja adjacent_find() domyślnie przeszukuje zakres danych określony przez iteratory //start//, //end// w celu odnalezienia dwóch idendtycznych, występujących kolejno 
elementów zawartych w strukturze danych. Porównanie elementów dokonywane jest przez zastosowanie operator==().
Możliwe jest także dostarczenie własnej funkcji porównującej elementy. Funkcja taka pobiera 2 argumenty i zwraca wartość logiczną TRUE ( gdy elemnty są równe)
w przeciwnym przypadku false;
===== Nagłówek =====
<code cpp>#include<alghoritm></code>

===== Definicja adjacent_find() =====
<code cpp>
template <class ForwardIterator> ForwardIterator adjacent_find ( ForwardIterator first, ForwardIterator last )
{
  ForwardIterator next=first; ++next;
  if (first != last)
    while (next != last)
      if (*first++ == *next++)  // or: if (pred(*first++,*next++)), for the pred version
        return first;
  return last;
}
</code>

===== Parametry ===== 
  * first  - iterator wskazujący początek zakresu do przeszukania
  * last   - iterator wskazujący koniec zakresu do przeszukania
  * binary_pred - opcjonalny argument, wskaźnik na funkcję dokonującej porównania

===== Przyklady =====

  * Najprostsze zastosowanie algorytmu

<code cpp>
#include<alghoritm>

int main() {
   vector<int> v1;

   for( int i = 0; i < 10; i++ ) {
     v1.push_back(i);
     
     // zmuszenie do zdublowania wartości 7 i 9
     if( i == 7 || i == 9 ) {
       v1.push_back(i);
     }
   }
 
   vector<int>::iterator result;
   result = adjacent_find( v1.begin(), v1.end() );
 
   if( result == v1.end() ) {
     cout << "Nie znaleziono dwóch identycznych kolejno występujących elemntów" << endl;
   }
   else {
     cout << "Znaleziona dwa identyczne kolejno występujące elementy. Pierwszy element: " << *result << endl;
   }

  result = adjacent_find (++result, v1.end());

  if (result == v1.end()) {
    cout << "Nie znaleziono drugiej pary identycznych kolejno występujących elementów" << endl;
  }
  else {
    cout << "Istnieje druga para identycznych kolejno występujących elementów. Pierwszy element: " << *result << std::endl;
  }

  return 0;
} 
</code>

  * Przykład z zastosownaniem 3 parametru algorytmu adjacent_find()
<code cpp>
#include<alghoritm>

// sprawdza czy następny element jest 2 razy większy od obecnego
bool twice (int elem1, int elem2 )
{
   return elem1 * 2 == elem2;
}


int main() {

  list <int> L;
  list <int>::iterator Iter;
  list <int>::iterator result;
   
  L.push_back( 50 );
  L.push_back( 40 );
  L.push_back( 10 );
  L.push_back( 20 );
  L.push_back( 20 );

  result = adjacent_find( L.begin( ), L.end( ), twice );
  if ( result2 == L.end( ) ) {
    cout << "Nie występuje para kolejnych elementów, w której jeden element jest dwukrotnie większy od drugiego" << endl;
  }
  else {
      cout << "Występuje para elementów w których jeden jest 2 razy większy od drugiego" << "\n Wartości tych elementów" << *(result++);
      cout << " i " << *result << endl;
  }



}
</code>
zpr c++ quick reference

Narzędzia użytkownika

Narzędzia witryny

Narzędzia strony
