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

greater() );

cout << "результат equal_range при поиске значения 26:\n\t"
<< "*ivec_iter.first: " << *ivec_iter.first << "\t"
<< "*ivec_iter.second: " << *ivec_iter.second
<< "\n\n";

ivec_iter = equal_range( ivec.begin(), ivec.end(), 21,
greater() );

cout << "результат equal_range при поиске отсутствующего значения 21:\n\t"
<< "*ivec_iter.first: " << *ivec_iter.first << "\t"
<< "*ivec_iter.second: " << *ivec_iter.second
<< "\n\n";
}
Алгоритм fill()
template< class ForwardIterator, class Type >
void
fill( ForwardIterator first,
ForwardIterator last, const Type& value );
fill() помещает копию значения value в каждый элемент диапазона, ограниченного парой итераторов [first,last).
#include
#include
#include
#include

/* печатается:
исходная последовательность элементов массива:
0 1 1 2 3 5 8

массив после fill(ia+1,ia+6):
0 9 9 9 9 9 8

исходная последовательность элементов списка:
c eiffel java ada perl

список после fill(++ibegin,--iend):
c c++ c++ c++ perl
*/

int main()
{
const int value = 9;
int ia[] = { 0, 1, 1, 2, 3, 5, 8 };
ostream_iterator< int > ofile( cout, " " );

cout << "исходная последовательность элементов массива:\n";
copy( ia, ia+7, ofile ); cout << "\n\n";

fill( ia+1, ia+6, value );

cout << "массив после fill(ia+1,ia+6):\n";
copy( ia, ia+7, ofile ); cout << "\n\n";

string the_lang( "c++" );
string langs[5] = { "c", "eiffel", "java", "ada", "perl" };

list< string, allocator > il( langs, langs+5 );
ostream_iterator< string > sofile( cout, " " );

cout << "исходная последовательность элементов списка:\n";
copy( il.begin(), il.end(), sofile ); cout << "\n\n";

typedef list::iterator iterator;

iterator ibegin = il.begin(), iend = il.end();
fill( ++ibegin, --iend, the_lang );

cout << "список после fill(++ibegin,--iend):\n";
copy( il.begin(), il.end(), sofile ); cout << "\n\n";
}
Алгоритм fill_n()
template< class ForwardIterator, class Size, class Type >
void
fill_n( ForwardIterator first,
Size n, const Type& value );
fill_n() присваивает count элементам из диапазона [first,first+count) значение value.
#include
#include
#include
#include

class print_elements {
public:
void operator()( string elem ) {
cout << elem
<< ( _line_cnt++%8 ? " " : "\n\t" );
}
static void reset_line_cnt() { _line_cnt = 1; }

private:
static int _line_cnt;
};

int print_elements::_line_cnt = 1;

/* печатается:
исходная последовательность элементов массива:
0 1 1 2 3 5 8

массив после fill_n( ia+2, 3, 9 ):
0 1 9 9 9 5 8
исходная последовательность строк:
Stephen closed his eyes to hear his boots
crush crackling wrack and shells

последовательность после применения fill_n():
Stephen closed his xxxxx xxxxx xxxxx xxxxx xxxxx
xxxxx crackling wrack and shells
*/

int main()
{
int value = 9; int count = 3;
int ia[] = { 0, 1, 1, 2, 3, 5, 8 };
ostream_iterator< int > iofile( cout, " " );

cout << "исходная последовательность элементов массива:\n";
copy( ia, ia+7, iofile ); cout << "\n\n";

fill_n( ia+2, count, value );

cout << "массив после fill_n( ia+2, 3, 9 ):\n";
copy( ia, ia+7, iofile ); cout << "\n\n";

string replacement( "xxxxx" );
string sa[] = { "Stephen", "closed", "his", "eyes", "to",
"hear", "his", "boots", "crush", "crackling",
"wrack", "and", "shells" };

vector< string, allocator > svec( sa, sa+13 );

cout << "исходная последовательность строк:\n\t";
for_each( svec.begin(), svec.end(), print_elements() );
cout << "\n\n";

fill_n( svec.begin()+3, count*2, replacement );

print_elements::reset_line_cnt();

cout << "последовательность после применения fill_n():\n\t";
for_each( svec.begin(), svec.end(), print_elements() );
cout << "\n";
}
Алгоритм find()
template< class InputIterator, class T >
InputIterator
find( InputIterator first,
InputIterator last, const T &value );
Элементы из диапазона, ограниченного парой итераторов [first,last), сравниваются со значением value с помощью оператора равенства, определенного для типа элементов контейнера. Как только соответствие найдено, поиск прекращается. find() возвращает итератор типа InputIterator, указывающий на найденный элемент; в противном случае возвращается last.
#include
#include
#include
#include

int main()
{
int array[ 17 ] = { 7,3,3,7,6,5,8,7,2,1,3,8,7,3,8,4,3 };

int elem = array[ 9 ];
int *found_it;

found_it = find( &array[0], &array[17], elem );

// печатается: поиск первого вхождения 1 найдено!

cout << "поиск первого вхождения "
<< elem << "\t"
<< ( found_it ? "найдено!\n" : "не найдено!\n" );

string beethoven[] = {
"Sonata31", "Sonata32", "Quartet14", "Quartet15",
"Archduke", "Symphony7" };

string s_elem( beethoven[ 1 ] );

list< string, allocator > slist( beethoven, beethoven+6 );
list< string, allocator >::iterator iter;

iter = find( slist.begin(), slist.end(), s_elem );

// печатается: поиск первого вхождения Sonata32 найдено!

cout << "поиск первого вхождения "
<< s_elem << "\t"
<< ( found_it ? "найдено!\n" : "не найдено!\n" );
}
Алгоритм find_if()
template< class InputIterator, class Predicate >
InputIterator
find_if( InputIterator first,
InputIterator last, Predicate pred );
К каждому элементу из диапазона [first,last) последовательно применяется предикат pred. Если он возвращает true, поиск прекращается. find_if() возвращает итератор типа InputIterator, указывающий на найденный элемент; в противном случае возвращается last.
#include
#include
#include
#include
#include

// альтернатива оператору равенства
// возвращает true, если строка содержится в объекте-члене FriendSet
class OurFriends { // наши друзья
public:
bool operator()( const string& str ) {
return ( friendset.count( str ));
}

static void
FriendSet( const string *fs, int count ) {
copy( fs, fs+count,
inserter( friendset, friendset.end() ));
}

private:
static set< string, less, allocator > friendset;
};

set< string, less, allocator > OurFriends::friendset;

int main()
{
string Pooh_friends[] = { "Пятачок", "Тигра", "Иа-Иа" };
string more_friends[] = { "Квазимодо", "Чип", "Пятачок" };
list lf( more_friends, more_friends+3 );

// заполнить список друзей Пуха
OurFriends::FriendSet( Pooh_friends, 3 );

list::iterator our_mutual_friend;
our_mutual_friend =
find_if( lf.begin(), lf.end(), OurFriends());

// печатается:
// Представьте-ка, наш друг Пятачок - также друг Пуха.
if ( our_mutual_friend != lf.end() )
cout << "Представьте-ка, наш друг "
<< *our_mutual_friend
<< " также друг Пуха.\n";

return 0;
}
Алгоритм find_end()
template< class ForwardIterator1, class ForwardIterator2 >
ForwardIterator1
find_end( ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2 );

template< class ForwardIterator1, class ForwardIterator2,
class BinaryPredicate >
ForwardIterator1
find_end( ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2,
BinaryPredicate pred );
В последовательности, ограниченной итераторами [first1,last1), ведется поиск последнего вхождения последовательности, ограниченной парой [first2,last2). Например, если первая последовательность – это Mississippi, а вторая – ss, то find_end() возвращает итератор, указывающий на первую s во втором вхождении ss. Если вторая последовательность не входит в первую, то возвращается last1. В первом варианте используется оператор равенства, определенный для типа элементов контейнера, а во втором – бинарный предикат, переданный пользователем.
#include
#include
#include
#include

int main()
{
int array[ 17 ] = { 7,3,3,7,6,5,8,7,2,1,3,7,6,3,8,4,3 };
int subarray[ 3 ] = { 3, 7, 6 };

int *found_it;

// find найти последнее вхождение последовательности 3,7,6
// в массив и вернуть адрес первого ее элемента ...

found_it = find_end( &array[0], &array[17],
&subarray[0], &subarray[3] );

assert( found_it == &array[10] );

vector< int, allocator > ivec( array, array+17 );
vector< int, allocator > subvec( subarray, subarray+3 );
vector< int, allocator >::iterator found_it2;

found_it2 = find_end( ivec.begin(), ivec.end(),
subvec.begin(), subvec.end(),
equal_to() );

assert( found_it2 == ivec.begin()+10 );

cout << "ok: find_end правильно вернула начало "
<< "последнего вхождения последовательности: 3,7,6!\n";
}
Алгоритм find_first_of()
template< class ForwardIterator1, class ForwardIterator2 >
ForwardIterator1
find_first_of( ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2 );

template< class ForwardIterator1, class ForwardIterator2,
class BinaryPredicate >
ForwardIterator1
find_first_of( ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2,
BinaryPredicate pred );
Последовательность, ограниченная парой [first2,last2), содержит элементы, поиск которых ведется в последовательности, ограниченной итераторами [first1,last1). Допустим, нужно найти первую гласную в последовательности символов synesthesia. Для этого определим вторую последовательность как aeiou. find_first_of() возвращает итератор, указывающий на первое вхождение любого элемента последовательности гласных букв, в данном случае e. Если же первая последовательность не содержит ни одного элемента из второй, то возвращается last1. В первом варианте используется оператор равенства, определенный для типа элементов контейнера, а во втором – бинарный предикат pred.

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

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