====== Algorytm adjacent_find() ======
template
ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last);
template
ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred);
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 =====
#include
===== Definicja adjacent_find() =====
template 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;
}
===== 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
#include
int main() {
vector 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::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;
}
* Przykład z zastosownaniem 3 parametru algorytmu adjacent_find()
#include
#include
#include
// sprawdza czy następny element jest 2 razy większy od obecnego
bool twice (int elem1, int elem2 )
{
return elem1 * 2 == elem2;
}
int main() {
std::list L;
std::list ::iterator result;
L.push_back( 50 );
L.push_back( 40 );
L.push_back( 10 );
L.push_back( 20 );
L.push_back( 20 );
result = std::adjacent_find( L.begin( ), L.end( ), twice );
if ( result == L.end( ) ) {
std::cout << "Nie występuje para kolejnych elementów, w której jeden element jest dwukrotnie większy od drugiego" << std::endl;
}
else {
std::cout << "Występuje para elementów w której jeden jest 2 razy większy od drugiego" << std::endl << "Wartości tych elementów" << *(result);
std::cout << " oraz " << *(++result) << std::endl;
}
}
===== adjacent_find.cpp =====
{{:stl_algorytmy:stl_algorytmy:adjacent_find2.cpp|}}