#include <numeric> #include <list> #include <functional> #include <iterator> #include <iostream.h>
int main()
{
int ia[] = { 1, 1, 2, 3, 5, 8 };
list<int,allocator> ilist(ia, ia+6); list<int,allocator> ilist_result(ilist.size());
adjacent_difference(ilist.begin(), ilist.end(), ilist_result.begin() );
//на выходе печатается:
//1 0 1 1 2 3
copy( ilist_result.begin(), ilist_result.end(), ostream_iterator<int>(cout," "));
cout << endl;
adjacent_difference(ilist.begin(), ilist.end(), ilist_result.begin(),
times<int>() );
//на выходе печатается:
//1 1 2 6 15 40
copy( ilist_result.begin(), ilist_result.end(), ostream_iterator<int>(cout," "));
cout << endl;
}
Алгоритм adjacent_find()
template < class ForwardIterator > ForwardIterator
adjacent_find( ForwardIterator first, ForwardIterator last );
template < class ForwardIterator, class BinaryPredicate > ForwardIterator
adjacent_find( ForwardIterator first,
ForwardIterator last, Predicate pred );
adjacent_find() ищет первую пару одинаковых соседних элементов в диапазоне, ограниченном итераторами [first,last). Если соседние дубликаты найдены, то алгоритм возвращает однонаправленный итератор, указывающий на первый элемент пары, в противном случае возвращается last. Например, если дана последовательность {0,1,1,2,2,4}, то будет найдена пара [1,1] и возвращен итератор, указывающий на первую единицу.
#include <algorithm> #include <vector> #include <iostream.h> #include <assert.h>
class TwiceOver { public:
bool operator() ( int val1, int val2 )
{ return val1 == val2/2 ? true : false; }
};
int main()
{
int ia[] = { 1, 4, 4, 8 };
vector< int, allocator > vec( ia, ia+4 );
int *piter;
vector< int, allocator >::iterator iter;
// piter указывает на ia[1]
piter = adjacent_find( ia, ia+4 ); assert( *piter == ia[ 1 ] );
// iter указывает на vec[2]
iter = adjacent_find( vec.begin(), vec.end(), TwiceOver() );
assert( *iter == vec[ 2 ] );
// пришли сюда: все хорошо
cout << "ok: adjacent-find() завершился успешно!\n";
return 0;
}
Алгоритм binary_search()
template < class ForwardIterator, class Type > bool
binary_search( ForwardIterator first, ForwardIterator last, const Type
&value );
template < class ForwardIterator, class Type > bool
binary_search( ForwardIterator first,
ForwardIterator last, const Type &value, Compare comp );
binary_search() ищет значение value в отсортированной последовательности, ограниченной парой итераторов [first,last). Если это значение найдено, возвращается true, иначе – false. В первом варианте предполагается, что контейнер отсортирован с помощью оператора “меньше”. Во втором варианте порядок определяется указанным объектом-функцией.
#include <algorithm> #include <vector> #include <assert.h>
int main()
{
int ia[] = {29,23,20,22,17,15,26,51,19,12,35,40}; vector< int, allocator > vec( ia, ia+12 );
sort( &ia[0], &ia[12] );
bool found_it = binary_search( &ia[0], &ia[12], 18 );
assert( found_it == false );
vector< int > vec( ia, ia+12 );
sort( vec.begin(), vec.end(), greater<int>() ); found_it = binary_search( vec.begin(), vec.end(),
26, greater<int>() ); assert( found_it == true );
}
Алгоритм copy()
template < class InputIterator, class OutputIterator
>
OutputIterator
copy( InputIterator first1, InputIterator last, OutputIterator first2 )
copy() копирует последовательность элементов, ограниченную парой итераторов [first,last), в другой контейнер, начиная с позиции, на которую указывает first2. Алгоритм возвращает итератор, указывающий на элемент второго контейнера, следующий за последним вставленным. Например, если дана последовательность
int ia[] = {0, 1, 2, 3, 4, 5 };
// сдвинуть элементы влево на один, получится {1,2,3,4,5,5}
{0,1,2,3,4,5}, мы можем сдвинуть элементы на один влево с помощью такого вызова: copy( ia+1, ia+6, ia );
copy() начинает копирование со второго элемента ia, копируя 1 в первую позицию, и так далее, пока каждый элемент не окажется в позиции на одну левее исходной.
#include <algorithm> #include <vector> #include <iterator> #include <iostream.h>
/* печатается:
0 1 1 3 5 8 13 сдвиг массива влево на 1: 1 1 3 5 8 13 13
сдвиг вектора влево на 2: 1 3 5 8 13 8 13
*/
int main()
{
int ia[] = { 0, 1, 1, 3, 5, 8, 13 }; vector< int, allocator > vec( ia, ia+7 );
ostream_iterator< int > ofile( cout, " " );
cout << "исходная последовательность элементов:\n"; copy( vec.begin(), vec.end(), ofile ); cout <<
'\n';
// сдвиг влево на один элемент copy( ia+1, ia+7, ia );
cout << "сдвиг массива влево на 1:\n"; copy( ia, ia+7, ofile ); cout << '\n';
// сдвиг влево на два элемента
copy( vec.begin()+2, vec.end(), vec.begin() );
cout << "сдвиг вектора влево на 2:\n";
copy( vec.begin(), vec.end(), ofile ); cout << '\n';
}
Алгоритм copy_backward()
template < class BidirectionalIterator1, class BidirectionalIterator2 >
BidirectionalIterator2 copy_backward( BidirectionalIterator1
first,
BidirectionalIterator1
last1,
BidirectionalIterator2 last2 )
copy_backward() ведет себя так же, как copy(), только элементы копируются в обратном порядке: копирование начинается с last1-1 и продолжается до first. Кроме того, элементы помещаются в целевой контейнер с конца, от позиции last2-1, пока не будет скопировано last1-first элементов.
Например, если дана последовательность {0,1,2,3,4,5}, мы можем скопировать последние три элемента (3,4,5) на место первых трех (0,1,2), установив first равным адресу значения 0, last1 – адресу значения 3, а last2 – адресу значения 5. Тогда элемент 5 попадает на место элемента 2, элемент 4 – на место 1, а элемент 3 – на место 0. В результате получим последовательность {3,4,5,3,4,5}.