template< class Type > const Type&

max( const Type &aval, const Type &bval );

template< class Type, class Compare > const Type&

max( const Type &aval, const Type &bval, Compare comp );

max() возвращает наибольшее из двух значений aval и bval. В первом варианте используется оператор “больше”, определенный в классе Type; во втором – операция сравнения comp.

template< class ForwardIterator > ForwardIterator

max_element( ForwardIterator first, ForwardIterator last );

template< class ForwardIterator, class Compare > ForwardIterator

max_element( ForwardIterator first,

Алгоритм max_element()

ForwardIterator last, Compare comp );

max_element() возвращает итератор, указывающий на элемент, который содержит наибольшее значение в последовательности, ограниченной диапазоном [first,last). В первом варианте используется оператор “больше”, определенный для типа элементов контейнера; во втором – операция сравнения comp.

template< class Type > const Type&

min( const Type &aval, const Type &bval );

template< class Type, class Compare > const Type&

Алгоритм min()

min( const Type &aval, const Type &bval, Compare comp );

min() возвращает меньшее из двух значений aval и bval. В первом варианте используется оператор “меньше”, определенный для типа Type; во втором – операция сравнения comp.

template< class ForwardIterator > ForwardIterator

min_element( ForwardIterator first, ForwardIterator last );

template< class ForwardIterator, class Compare > ForwardIterator

min_element( ForwardIterator first,

Алгоритм min_element()

ForwardIterator last, Compare comp );

max_element() возвращает итератор, указывающий на элемент, который содержит наименьшее значение последовательности, ограниченной диапазоном [first,last). В первом варианте используется оператор “меньше”, определенный для типа элементов

// иллюстрирует max(), min(), max_element(), min_element()

#include <algorithm> #include <vector> #include <iostream.h>

int main()

{

int ia[] = { 7, 5, 2, 4, 3 };

const vector< int, allocator > ivec( ia, ia+5 );

int mval = max( max( max( max(ivec[4],ivec[3]), ivec[2]),ivec[1]),ivec[0]);

// вывод: результат вложенных вызовов max() равен: 7 cout << "результат вложенных вызовов max() равен: "

<< mval << endl;

mval = min( min( min( min(ivec[4],ivec[3]), ivec[2]),ivec[1]),ivec[0]);

// вывод: результат вложенных вызовов min() равен: 2 cout << "результат вложенных вызовов min() равен: "

<< mval << endl;

vector< int, allocator >::const_iterator iter; iter = max_element( ivec.begin(), ivec.end() );

// вывод: результат вложенных вызовов max_element() также равен: 7 cout << "результат вложенных вызовов max_element() также равен: "

<< *iter << endl;

iter = min_element( ivec.begin(), ivec.end() );

// вывод: результат вложенных вызовов min_element() также равен: 2 cout << "результат вложенных вызовов min_element() также равен: "

<< *iter << endl;

контейнера; во втором – операция сравнения comp.

}

template< class InputIterator1, class InputIterator2, class OutputIterator >

OutputIterator

merge( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result );

template< class InputIterator1, class InputIterator2, class OutputIterator, class Compare >

OutputIterator

merge( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2,

Алгоритм merge()

OutputIterator result, Compare comp );

merge() объединяет две отсортированные последовательности, ограниченные диапазонами [first1,last1) и [first2,last2), в единую отсортированную последовательность, начинающуюся с позиции result. Результирующий итератор записи указывает на элемент за концом новой последовательности. В первом варианте для упорядочения используется оператор “меньше”, определенный для типа элементов контейнера; во втором – операция сравнения comp.

InputIterator2 first2, BinaryPredicate pred );

mismatch() сравнивает две последовательности и находит первую позицию, где элементы различны. Возвращается пара итераторов, каждый из которых указывает на эту позицию в соответствующей последовательности. Если все элементы одинаковы, то каждый итератор в паре указывает на элемент last в своем контейнере. Так, если даны последовательности meet и meat, то оба итератора указывают на третий элемент. В первом варианте для сравнения элементов применяется оператор равенства, а во втором – операция сравнения, заданная пользователем. Если вторая последовательность длиннее первой, “лишние” элементы игнорируются; если же она

#include <algorithm> #include <list> #include <utility> #include <iostream.h>

class equal_and_odd{ public:

bool operator()( int ival1, int ival2 )

{

//оба значения равны друг другу?

//оба равны нулю? оба нечетны?

return ( ival1 == ival2 &&

( ival1 == 0 || ival1%2 ));

}

};

int main()

{

pair<int*,int*> pair_ia = mismatch( ia, ia+7, ia2 );

// печатается: первая пара неодинаковых: ia: 3 и ia2: 4 cout << "первая пара неодинаковых: ia: "

<<*pair_ia.first << " и ia2: "

<<*pair_ia.second << endl;

list<int,allocator> ilist( ia, ia+7 ); list<int,allocator> ilist2( ia2, ia2+7 );

typedef list<int,allocator>::iterator iter; pair<iter,iter> pair_ilist =

mismatch( ilist.begin(), ilist.end(), ilist2.begin(), equal_and_odd() );

//печатается: первая пара неодинаковых: либо не равны, либо не нечетны:

//ilist: 2 и ilist2: 2

cout << "первая пара неодинаковых: либо не равны, "

<<"либо не нечетны: \n\tilist: "

<<*pair_ilist.first << " и ilist2: "

<<*pair_ilist.second << endl;

короче, то поведение программы не определено.

}