С ДЛЯ НАЧИНАЮЩИХ М 2006 24 С 107

#include
#include
#include
#include

int main()
{
string s_array[] = { "Ee", "eE", "ee", "Oo", "oo", "ee" };

// возвращает первое вхождение "ee" -- &s_array[2]
string to_find[] = { "oo", "gg", "ee" };

string *found_it =
find_first_of( s_array, s_array+6,
to_find, to_find+3 );
// печатается:
// найдено: ee
// &s_array[2]: 0x7fff2dac
// &found_it: 0x7fff2dac

if ( found_it != &s_array[6] )
cout << "найдено: " << *found_it << "\n\t"
<< "&s_array[2]:\t" << &s_array[2] << "\n\t"
<< "&found_it:\t" << found_it << "\n\n";

vector< string, allocator > svec( s_array, s_array+6);
vector< string, allocator > svec_find( to_find, to_find+2 );

// возвращает вхождение "oo" -- svec.end()-2
vector< string, allocator >::iterator found_it2;

found_it2 = find_first_of(
svec.begin(), svec.end(),
svec_find.begin(), svec_find.end(),
equal_to() );

// печатает:
// тоже найдено: oo
// &svec.end()-2: 0x100067b0
// &found_it2: 0x100067b0

if ( found_it2 != svec.end() )
cout << "тоже найдено: " << *found_it2 << "\n\t"
<< "&svec.end()-2:\t" << svec.end()-2 << "\n\t"
<< "&found_it2:\t" << found_it2 << "\n";
}
Алгоритм for_each()
template< class InputIterator, class Function >
Function
for_each( InputIterator first,
InputIterator last, Function func );
for_each() применяет объект-функцию func к каждому элементу в диапазоне [first,last). func не может изменять элементы, поскольку итератор записи не гарантирует поддержки присваивания. Если же модификация необходима, следует воспользоваться алгоритмом transform(). func может возвращать значение, но оно игнорируется.
#include
#include
#include

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

int main()
{
vector< int, allocator > ivec;

for ( int ix = 0; ix < 10; ix++ )
ivec.push_back( ix );

void (*pfi)( int ) = print_elements;
for_each( ivec.begin(), ivec.end(), pfi );

return 0;
}
Алгоритм generate()
template< class ForwardIterator, class Generator >
void
generate( ForwardIterator first,
ForwardIterator last, Generator gen );
generate() заполняет диапазон, ограниченный парой итераторов [first,last), путем последовательного вызова gen, который может быть объектом-функцией или указателем на функцию.
#include
#include
#include

int odd_by_twos() {
static int seed = -1;
return seed += 2;
}

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

int main()
{
list< int, allocator > ilist( 10 );
void (*pfi)( int ) = print_elements;

generate( ilist.begin(), ilist.end(), odd_by_twos );

// печатается:
// элементы в списке, первый вызов:
// 1 3 5 7 9 11 13 15 17 19

cout << "элементы в списке, первый вызов:\n";
for_each( ilist.begin(), ilist.end(), pfi );
generate( ilist.begin(), ilist.end(), odd_by_twos );

// печатается:
// элементы в списке, второй вызов:
// 21 23 25 27 29 31 33 35 37 39
cout << "\n\nэлементы в списке, второй вызов:\n";
for_each( ilist.begin(), ilist.end(), pfi );

return 0;
}
Алгоритм generate_n()
template< class OutputIterator,
class Size, class Generator >
void
generate_n( OutputIterator first, Size n, Generator gen );
generate_n() заполняет последовательность, начиная с first, n раз вызывая gen, который может быть объектом-функцией или указателем на функцию.
#include
#include
#include

class even_by_twos {
public:
even_by_twos( int seed = 0 ) : _seed( seed ){}
int operator()() { return _seed += 2; }
private:
int _seed;
};

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

int main()
{
list< int, allocator > ilist( 10 );
void (*pfi)( int ) = print_elements;

generate_n( ilist.begin(), ilist.size(), even_by_twos() );

// печатается:
// generate_n с even_by_twos():
// 2 4 6 8 10 12 14 16 18 20

cout << "generate_n с even_by_twos():\n";
for_each( ilist.begin(), ilist.end(), pfi ); cout << "\n";
generate_n( ilist.begin(), ilist.size(), even_by_twos( 100 ) );

// печатается:
// generate_n с even_by_twos( 100 ):
// 102 104 106 108 110 112 114 116 118 120

cout << "generate_n с even_by_twos( 100 ):\n";
for_each( ilist.begin(), ilist.end(), pfi );
}
Алгоритм includes()
template< class InputIterator1, class InputIterator2 >
bool
includes( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2 );

template< class InputIterator1, class InputIterator2,
class Compare >
bool
includes( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
Compare comp );
includes() проверяет, каждый ли элемент последовательности [first1,last1) входит в последовательность [first2,last2). Первый вариант предполагает, что последовательности отсортированы в порядке, определяемом оператором “меньше”; второй – что порядок задается параметром-типом comp.
#include
#include
#include

int main()
{
int ia1[] = { 13, 1, 21, 2, 0, 34, 5, 1, 8, 3, 21, 34 };
int ia2[] = { 21, 2, 8, 3, 5, 1 };

// алгоритму includes следует передавать отсортированные контейнеры
sort( ia1, ia1+12 ); sort( ia2, ia2+6 );

// печатает: каждый элемент ia2 входит в ia1? Да

bool res = includes( ia1, ia1+12, ia2, ia2+6 );
cout << "каждый элемент ia2 входит в ia1? "
<< (res ? "Да" : "Нет") << endl;

vector< int, allocator > ivect1( ia1, ia1+12 );
vector< int, allocator > ivect2( ia2, ia2+6 );

// отсортирован в порядке убывания
sort( ivect1.begin(), ivect1.end(), greater() );
sort( ivect2.begin(), ivect2.end(), greater() );

res = includes( ivect1.begin(), ivect1.end(),
ivect2.begin(), ivect2.end(),
greater() );

// печатает: каждый элемент ivect2 входит в ivect1? Да

cout << "каждый элемент ivect2 входит в ivect1? "
<< (res ? "Да" : "Нет") << endl;

}
Алгоритм inner_product()
template< class InputIterator1, class InputIterator2
class Type >
Type
inner_product(
InputIterator1 first1, InputIterator1 last,
InputIterator2 first2, Type init );

template< class InputIterator1, class InputIterator2
class Type,
class BinaryOperation1, class BinaryOperation2 >
Type
inner_product(
InputIterator1 first1, InputIterator1 last,
InputIterator2 first2, Type init,
BinaryOperation1 op1, BinaryOperation2 op2 );
Первый вариант суммирует произведения соответственных членов обеих последовательностей и прибавляет результат к начальному значению init. Первая последовательность ограничена итераторами [first1,last1), вторая начинается с first2 и обходится синхронно с первой. Например, если даны последовательности {2,3,5,8} и {1,2,3,4}, то результат вычисляется следующим образом:

2*1 + 3*2 + 5*3 + 8*4

Если начальное значение равно 0, алгоритм вернет 55.
Во втором варианте вместо сложения используется бинарная операция op1, а вместо умножения – бинарная операция op1. Например, если для приведенных выше последовательностей применить вычитание в качестве op1 и сложение в качестве op2, то результат будет вычисляться так:

(2+1) - (3+2) - (5+3) - (8+4)

inner_product() – это один из численных алгоритмов. Для его использования в программу необходимо включить заголовочный файл .
#include
#include
#include

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 vec( ia, ia+4 );
vector vec2( ia2, ia2+4 );

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

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

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

return 0;
}
Алгоритм inplace_merge()
template< class BidirectionalIterator >
void
inplace_merge( BidirectionalIterator first,
BidirectionalIterator middle,
BidirectionalIterator last );

template< class BidirectionalIterator, class Compare >
void
inplace_merge( BidirectionalIterator first,
BidirectionalIterator middle,
BidirectionalIterator last, Compare comp );
inplace_merge() объединяет две соседние отсортированные последовательности, ограниченные парами итераторов [first,middle) и [middle,last). Результирующая последовательность затирает исходные, начиная с позиции first. В первом варианте для упорядочения элементов используется оператор “меньше”, определенный для типа элементов контейнера, во втором – операция сравнения, переданная программистом.
#include
#include
#include

template
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()
{

<< Пред. стр. 107 (из 121) След. >>

Список литературы по разделу