Программирование на C / C++ / Ален И. Голуб. Правила программирования на Си и Си++ [pdf]

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

int main()

{

int ia[] = { 2, 3, 5, 8 }; int ia2[] = { 1, 2, 3, 4 };

//перемножить пары элементов из обоих массивов,

//сложить и добавить начальное значение: 0

int res = inner_product( &ia[0], &ia[4], &ia2[0], 0 );

// печатает: скалярное произведение массивов: 55 cout << "скалярное произведение массивов: "

<< res << endl;

vector<int, allocator> vec( ia, ia+4 ); vector<int, allocator> vec2( ia2, ia2+4 );

//сложить пары элементов из обоих векторов,

//вычесть из начального значения: 0

res = inner_product( vec.begin(), vec.end(), vec2.begin(), 0,

minus<int>(), plus<int>() );

// печатает: скалярное произведение векторов: -28 cout << "скалярное произведение векторов: "

<< res << endl;

return 0;

}

template< class BidirectionalIterator > void

inplace_merge( BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last );

template< class BidirectionalIterator, class Compare > void

inplace_merge( BidirectionalIterator first, BidirectionalIterator middle,

Алгоритм inplace_merge()

BidirectionalIterator last, Compare comp );

inplace_merge() объединяет две соседние отсортированные последовательности, ограниченные парами итераторов [first,middle) и [middle,last). Результирующая последовательность затирает исходные, начиная с позиции first. В первом варианте

для упорядочения элементов используется оператор “меньше”, определенный для типа

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

template <class Type>

void print_elements( Type elem ) { cout << elem << " "; }

/* * печатает:

ia разбит на два отсортированных подмассива:

12 15 17 20 23 26 29 35 40 51 10 16 21 41 44 54 62 65 71 74

ia inplace_merge:

10 12 15 16 17 20 21 23 26 29 35 40 41 44 51 54 62 65 71 74

ivec разбит на два отсортированных подвектора:

51 40 35 29 26 23 20 17 15 12 74 71 65 62 54 44 41 21 16 10

ivec inplace_merge:

74 71 65 62 54 51 44 41 40 35 29 26 23 21 20 17 16 15 12 10 */

int main()

{

int ia[] = { 29,23,20,17,15,26,51,12,35,40, 74,16,54,21,44,62,10,41,65,71 };

vector< int, allocator > ivec( ia, ia+20 ); void (*pfi)( int ) = print_elements;

// отсортировать обе подпоследовательности sort( &ia[0], &ia[10] );

sort( &ia[10], &ia[20] );

cout << "ia разбит на два отсортированных подмассива: \n"; for_each( ia, ia+20, pfi ); cout << "\n\n";

inplace_merge( ia, ia+10, ia+20 );

cout << "ia inplace_merge:\n"; for_each( ia, ia+20, pfi ); cout << "\n\n";

cout << "ivec разбит на два отсортированных подвектора: \n"; for_each( ivec.begin(), ivec.end(), pfi ); cout << "\n\n";

inplace_merge( ivec.begin(), ivec.begin()+10, ivec.end(), greater<int>() );

cout << "ivec inplace_merge:\n";

for_each( ivec.begin(), ivec.end(), pfi ); cout << endl;

элементов контейнера, во втором – операция сравнения, переданная программистом.

}

template< class ForwardIterator1, class ForwardIterator2 > void

Алгоритм iter_swap()

iter_swap( ForwardIterator1 a, ForwardIterator2 b );

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

int main()

{

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

list< int,allocator > ilist( ia, ia+6 );

typedef list< int, allocator >::iterator iterator; iterator iter1 = ilist.begin(),iter2,

iter_end = ilist.end();

// отсортировать список "пузырьком" ...

for ( ; iter1 != iter_end; ++iter1 )

for ( iter2 = iter1; iter2 != iter_end; ++iter2 ) if ( *iter2 < *iter1 )

iter_swap( iter1, iter2 );

//печатается:

//ilist после сортировки "пузырьком" с помощью iter_swap():

//{ 0 1 2 3 4 5 }

cout << "ilist после сортировки "пузырьком" с помощью iter_swap(): { ";

for ( iter1 = ilist.begin(); iter1 != iter_end; ++iter1 ) cout << *iter1 << " ";

cout << "}\n";

return 0;

iter_swap() обменивает значения элементов, на которые указывают итераторы a и b.

}

template< class InputIterator1, class InputIterator2 > bool

lexicographical_compare(

InputIterator1 first1, InputIterator1 last1, InputIterator1 first2, InputIterator2 last2 );

template< class InputIterator1, class InputIterator2, class Compare >

bool lexicographical_compare(

InputIterator1 first1, InputIterator1 last1, InputIterator1 first2, InputIterator2 last2,

Алгоритм lexicographical_compare()

Compare comp );

lexicographical_compare() сравнивает соответственные пары элементов из двух последовательностей, ограниченных диапазонами [first1,last1) и [first2,last2). Сравнение продолжается, пока не будет найдена первая пара различных элементов, не достигнута пара [last1,last2] или хотя бы один из элементов last1 или last2 (если последовательности имеют разные длины). При обнаружении первой пары различных элементов алгоритм возвращает:

∙если меньше элемент первой последовательности, то true, иначе false;

∙если last1 достигнут, а last2 нет, то true;

∙если last2 достигнут, а last1 нет, то false;

∙если достигнуты и last1, и last2 (т.е. все элементы одинаковы), то false. Иными словами, первая последовательность лексикографически не меньше второй.

string arr1[] = { "Piglet", "Pooh", "Tigger" };

Например, даны такие последовательности:

string arr2[] = { "Piglet", "Pooch", "Eeyore" };

В них первая пара элементов одинакова, а вторая различна. Pooh считается больше, чем Pooch, так как c лексикографически меньше h (такой способ сравнения применяется при составлении словарей). В этом месте алгоритм заканчивается (третья пара элементов не сравнивается). Результатом сравнения будет false.

Во втором варианте алгоритма вместо оператора сравнения используется предикатный объект:

template< class ForwardIterator, class Type > ForwardIterator

lower_bound( ForwardIterator first,

ForwardIterator last, const Type &value );

template< class ForwardIterator, class Type, class Compare > ForwardIterator

lower_bound( ForwardIterator first,

ForwardIterator last, const Type &value,

class Compare );

lower_bound() возвращает итератор, указывающий на первую позицию в отсортированной последовательности, ограниченной диапазоном [first,last), в которую можно вставить значение value, не нарушая упорядоченности. В этой позиции находится значение, большее либо равное value. Например, если дана такая последовательность:

int ia = = {12,15,17,19,20,22,23,26,29,35,40,51};

то обращение к lower_bound() с аргументом value=21 возвращает итератор, указывающий на 23. Обращение с аргументом 22 возвращает тот же итератор. В первом варианте алгоритма используется оператор “меньше”, определенный для типа элементов контейнера, а во втором для упорядочения элементов применяется объект comp.

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.