WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     | 1 | 2 ||

«Министерство образования Республики Беларусь Учреждение образования «Белорусский государственный университет информатики и радиоэлектроники» Кафедра электронных вычислительных машин Ю.А. Луцик, А.М. ...»

-- [ Страница 3 ] --

Задание собственной функции завершения Если программа не может найти подходящий обработчик для сгенериро ванной исключительной ситуации, то будет вызвана процедура завершения terminate() (ее также называют обработчик завершения), по умолчанию выпол нение программы будет остановлено и на экран будет выведено сообщение «Abnormal program termination». Однако можно установить собственный обра ботчик завершения, используя функцию set_terminate(), единственным аргумен том которой является указатель на новую функцию завершения (функция, при нимающая и возвращающая void), а возвращаемое значение – указатель на пре дыдущий обработчик. Ниже приведен пример установки собственного обра ботчика завершения и генерации исключительной ситуации, для которой не может быть найден обработчик.

#include #include #include void my_term() { cout<<"Собственная функция-обработчик";

exit(1);

} void main() { set_terminate(my_term);

try { throw 1;

// генерация исключительной ситуации типа int } catch(char) { // обработчик для типа char cout<<"char handler";

} } Результат выполнения программы:

Собственная функция-обработчик Спецификации исключительных ситуаций Иногда возникает необходимость заранее указать, какие исключения мо гут генерироваться в той или иной функции. Это можно сделать с помощью так называемой спецификации исключительных ситуаций. Это средство позволяет указать в объявлении функции типы исключительных ситуаций, которые могут в ней генерироваться. Синтаксис спецификации имеет вид:

объявление функции throw(тип1, тип2,…){тело функции} Использование спецификации исключительных ситуаций не означает, что в функции не может быть сгенерирована исключительная ситуация некоторого не указанного в спецификации типа. Просто в этом случае программа по умол чанию завершится, так как подобные действия приведут к вызову неожиданно го обработчика. Таким образом, когда функция генерирует исключительную ситуацию, не описанную в спецификации, выполняется неожиданный обработ чик.

Задание собственного неожиданного обработчика Так же как и обработчик terminate(), обработчик unexpected() позволяет перед завершением программы выполнить какие-то действия. Но в отличие от обработчика завершения неожиданный обработчик может сам генерировать ис ключительные ситуации. Таким образом, собственный неожиданный обработ чик может сгенерировать исключительную ситуацию, на этот раз уже входя щую в спецификацию. Установка собственного неожиданного обработчика вы полняется с помощью функции set_unexpected().

Приведенная ниже программа демонстрирует применение спецификации исключений и перехват неожиданных исключительных ситуаций с помощью собственного обработчика.

#include #include class first{};

class second : public first{};

class third : public first{};

class my_class{};

void my_unexpected() { cout<<"my_unexpected handler"<

throw third();

// возбуждение исключения типа объект } // класса third void f(int i) throw(first) // указание спецификации исключения { if(i ) throw second();

// else throw my_unexpected();

} void main() { set_unexpected(my_unexpected);

try { f(1);

} catch(first) { cout<<"first handler"<

} catch(my_class) { cout<<"my_class handler"<

} try{ f(0);

} catch(first) { cout<<"first handler"<

} catch(my_class) { cout<<"my_class handler"<

} } Результат выполнения программы.

first handler my_unexpected handler first handler В данной программе вызов функции f() во втором блоке try приводит к тому, что генерируется исключительная ситуация, тип которой не указан в спе цификации, поэтому вызывается установленный нами неожиданный обработ чик, где происходит генерация исключения, которое успешно обрабатывается.

Иерархия исключений стандартной библиотеки Вершиной иерархии является класс exceptioh (определенный в заголовоч ном файле ). В этом классе содержится функция what(), переопреде ляемая в каждом производном классе для выдачи сообщения об ошибке.

Непосредственными производными классами от класса exception являют ся классы runtime_error и logic_error (определенные в заголовочном файле ), имеющие по несколько производных классов.

Производными от exception также являются исключения: bad_alloc, гене рируемое оператором new, bad_cast, генерируемое dynamic_cast, и bad_typeid, генерируемое оператором typeid.

Класс logic_error и производные от него классы (invalid_argument, length_error, out_of_range) указывают на логические ошибки (передача непра вильного аргумента функции, выход за пределы массива или строки).

Класс runtime_error и производные от него (overflow_error и underflow_error) указывают на математические ошибки переполнения сверху и снизу.

Стандартная библиотека шаблонов (STL) Общее понятие о контейнере Стандартная библиотека шаблонов (Standard Template Library, STL) вхо дит в стандартную библиотеку языка C++. В неё включены реализации наибо лее часто используемых контейнеров и алгоритмов, что избавляет программи стов от рутинного переписывания их снова и снова. При разработке контейне ров и применяемых к ним алгоритмов (таких как удаление одинаковых элемен тов, сортировка, поиск и т. д.) часто приходится приносить в жертву либо уни версальность, либо быстродействие. Однако разработчики STL поставили перед собой задачу: сделать библиотеку одновременно эффективной и универсаль ной. Для ее решения были использованы такие универсальные средства языка C++, как шаблоны и перегрузка операторов. В последующем изложении будем опираться на реализацию STL, поставляемую фирмой Microsoft вместе с ком пилятором Visual C++ 6.0. Тем не менее большая часть сказанного будет спра ведлива и для реализаций STL другими компиляторами.

Основными понятиями в STL являются понятия контейнера (container), алгоритма (algorithm) и итератора (iterator).

Контейнер – это хранилище объектов (как встроенных, так и определён ных пользователем типов). Как правило, контейнеры реализуются в виде шаб лонов классов. Простейшие виды контейнеров (статические и динамические массивы) встроены непосредственно в язык C++. Кроме того, стандартная биб лиотека включает в себя реализации таких контейнеров, как вектор (vector), список (list), очередь (deque), ассоциативный массив (map), множество (set) и некоторых других.

Алгоритм – это функция для манипулирования объектами, содержащи мися в контейнере. Типичные примеры алгоритмов – сортировка и поиск. В STL реализовано порядка 60 алгоритмов, которые можно применять к различ ным контейнерам, в том числе к массивам, встроенным в язык C++.

Итератор – это абстракция указателя, то есть объект, который может ссылаться на другие объекты, содержащиеся в контейнере. Основные функции итератора – обеспечение доступа к объекту, на который он ссылается (разыме нование), и переход от одного элемента контейнера к другому (итерация, отсю да и название итератора). Для встроенных контейнеров в качестве итераторов используются обычные указатели. В случае с более сложными контейнерами итераторы реализуются в виде классов с набором перегруженных операторов.

Помимо отмеченных элементов в STL есть ряд вспомогательных поня тий;

с некоторыми из них следует также познакомиться.

Аллокатор (allocator) – это объект, отвечающий за распределение памяти для элементов контейнера. С каждым стандартным контейнером связывается аллокатор (его тип передаётся как один из параметров шаблона). Если какому то алгоритму требуется распределять память для элементов, он обязан делать это через аллокатор. В этом случае можно быть уверенным, что распределён ные объекты будут уничтожены правильно.

В состав STL входит стандартный класс allocator (описан в файле xmemory). Именно его по умолчанию используют все контейнеры, реализован ные в STL. Однако пользователь может реализовать собственный класс. Необ ходимость в этом возникает очень редко, но иногда это можно сделать из сооб ражений эффективности или в отладочных целях.

Остановимся более подробно на рассмотрении введенных понятий.

Контейнеры. Каждый контейнер предоставляет строго определённый интерфейс, через который с ним будут взаимодействовать алгоритмы. Этот ин терфейс обеспечивают соответствующие контейнеру итераторы. Важно под черкнуть, что никакие дополнительные функции-члены для взаимодействия ал горитмов и контейнеров не используются. Это сделано потому, что стандарт ные алгоритмы должны работать, в том числе со встроенными контейнерами языка C++, у которых есть итераторы (указатели), но нет ничего, кроме них.

Таким образом, при создании собственного контейнера реализация итератора – необходимый минимум.

Каждый контейнер реализует определённый тип итераторов. При этом выбирается наиболее функциональный тип итератора, который может быть эф фективно реализован для данного контейнера. «Эффективно» означает, что скорость выполнения операций над итератором не должна зависеть от количе ства элементов в контейнере. Например, для вектора реализуется итератор с произвольным доступом, а для списка – двунаправленный. Поскольку скорость выполнения операции [] для списка линейно зависит от его длины, итератор с произвольным доступом для списка не реализуется.

Вне зависимости от фактической организации контейнера (вектор, спи сок, дерево) хранящиеся в нём элементы можно рассматривать как последова тельность. Итератор первого элемента в этой последовательности возвращает функция begin(), а итератор элемента, следующего за последним, – функция end(). Это очень важно, так как все алгоритмы в STL работают именно с после довательностями, заданными итераторами начала и конца.

Кроме обычных итераторов в STL существуют обратные итераторы (reverse iterator). Обратный итератор отличается тем, что просматривает после довательность элементов в контейнере в обратном порядке. Другими словами, операции + и – у него меняются местами. Это позволяет применять алгоритмы как к прямой, так и к обратной последовательности элементов. Например, с по мощью функции find можно искать элементы как "с начала", так и "с конца" контейнера.

В STL контейнеры делятся на три основные группы (табл. 2): контейнеры последовательностей, ассоциативные контейнеры и адаптеры контейнеров.

Первые две группы объединяются в контейнеры первого класса.

Таблица Контейнерный Описание класс STL Контейнеры последовательностей Динамический массив vector Двунаправленная очередь deque Двунаправленный линейный список List Ассоциативные контейнеры Ассоциативный контейнер с уникальными ключами Set Ассоциативный контейнер, допускающий дублирование multiset ключей Ассоциативный контейнер для наборов уникальных эле Map ментов Ассоциативный контейнер для наборов с дублированием multimap элементов Адаптеры контейнеров Стандартный стек Stack Стандартная очередь queue Очередь с приоритетами priority_queue Каждый класс контейнера, реализованный в STL, описывает набор типов, связанных с контейнером. При написании собственных контейнеров следует придерживаться этой же практики. Вот список наиболее важных типов:

value_type – тип элемента;

size_type – тип для хранения числа элементов (обычно size_t);

iterator – итератор для элементов контейнера;

key_type – тип ключа (в ассоциативном контейнере).

Помимо типов можно выделить набор функций, которые реализует почти каждый контейнер в STL (табл. 3). Они не требуются для взаимодействия с ал горитмами, но их реализация улучшает взаимозаменяемость контейнеров в про грамме. STL разработана с тем расчетом, чтобы контейнеры обеспечивали ана логичные функциональные возможности.

Таблица Общие методы всех Описание STL-контейнеров 1 Конструктор по умолчанию. Обычно контейнер име default ет несколько конструкторов constructor Копирующий конструктор copy constructor Деструктор destructor Возвращает true, если в контейнере нет элементов, empty иначе false Возвращает максимальное число элементов для max_size контейнера Возвращает число элементов в контейнере в текущее size время Присваивает один контейнер другому operator = Возвращает true, если первый контейнер меньше operator < второго, иначе false Возвращает true, если первый контейнер не больше operator <= второго, иначе false Возвращает true, если первый контейнер больше operator > второго, иначе false Возвращает true, если первый контейнер не меньше operator >= второго, иначе false Возвращает true, если сравниваемые контейнеры operator == равны, иначе false Возвращает true, если сравниваемые контейнеры не operator != равны, иначе false Меняет местами элементы двух контейнеров swap Функции, имеющиеся только в контейнерах первого класса Две версии этой функции возвращают либо iterator, begin либо const_iterator, который ссылается на первый элемент контейнера Две версии этой функции возвращают либо iterator, end либо const_iterator, который ссылается на следующую позицию после конца контейнера Две версии этой функции возвращают либо rbegin reverse_iterator, либо reverse_const_iterator, который ссылается на последний элемент контейнера Две версии этой функции возвращают либо rend reverse_iterator, либо reverse_const_iterator, который ссылается на позицию перед первым элементом контейнера Позволяют вставить или удалить элемент(ы) в insert, erase, середине последовательности Окончание табл. 1 Удаляет из контейнера все элементы clear Возвращают ссылки на первый и последний элемент, front, back хранящийся в контейнере Позволяют добавить или удалить последний элемент в push_back, последовательности pop_back Позволяют добавить или удалить первый элемент в push_front, последовательности pop_front Итераторы обычно создаются как друзья классов, с которыми они рабо тают, что позволяет выполнить прямой доступ к частным данным этих классов.

С одним контейнером может быть связано несколько итераторов, каждый из которых поддерживает свою собственную «позиционную информацию» (табл. 4).

Таблица Тип итератора Доступ Разыменование Итерация Сравнение Итератор вывода Только * ++ (output iterator) запись Итератор ввода Только *, -> ++ ==, != (input iterator) чтение Прямой итератор Чтение и *, -> ++ ==, != (forward iterator) запись Двунаправленный ите- Чтение и *, -> ++, -- ==, != ратор (bidirectional запись iterator) Итератор с произволь- Чтение и *, ->, [] ++, --, +, -, ==, !=, <, ным доступом запись +=, -= <=, >, >= (random-access iterator) Общее понятие об итераторе Для структурированных итераций, например, при обработке массивов:

for(i=0;

i

i++) sm+=a[i];

порядок обращения к элементу управляется индексом i, который изменяется явно. Можно зафиксировать получение следующего элемента в компоненте функции.

class vect { int *p;

// массив чисел int size;

// размерность массива int ind;

// текущий индекс public:

vect();

// размерность массива const vect(int SIZE);

// размерность массива size ~vect();

int ub(){return size-1;

} int next() { if(ind==pv->size) return pv->p[(ind=0)++];

else return pv->p[ind++];

} };

Это соответствует тому, что обращение к объекту ограничивается ис пользованием одного индекса ind. Другая возможность состоит в том, чтобы создать множество индексов и передавать функции обращения к элементу один из них. Это ведет к существенному увеличению числа переменных. Более удоб ным представляется создание отдельного, связанного с vect класса (класса ите раций), в функции которого входит обращение к элементам класса vect.

#include class vect { friend class vect_iterator;

// предварительное friend-объявление int *p;

// базовый указатель (массив) int size;

// размерность массива public:

vect(int SIZE):size(SIZE) { p=new int[size];

for(int i=0;

i

*(p+i++)=i);

} int ub(){return size-1;

} // возвращается размер массива void add() // изменение содержимого массива { for(int i=0;

i

*(p+i++)+=1);

} ~vect(){delete [] p;

} };

class vect_iterator { vect *pv;

// указатель на класс vect int ind;

// текущий индекс в массиве public:

vect_iterator(vect &v): ind(0),pv(&v){} int &next();

//возвращается текущее значение из массива (с индекса ind) };

int &vect_iterator::next() { if(ind==pv->size) return pv->p[(ind=0)++];

else return pv->p[ind++];

} void main() { vect v(5);

vect_iterator v_i1(v),v_i2(v);

// создано 2 объекта-итератора // для прохода по объекту vect cout<

v.add();

// модификация объекта v cout<

for(int i=0;

i

i++) cout<

} Результат работы программы:

0 2 Полное отсоединение обращения от составного объекта позволяет объяв лять столько объектов итераторов, сколько необходимо. При этом каждый из объектов итераторов может просматривать объект vect независимо от других.

Итератор представляет собой операцию, обеспечивающую последова тельный доступ ко всем частям объекта. Итераторы имеют свойства, похожие на свойства указателей, и могут быть использованы для указания на элементы контейнеров первого класса. Итераторы реализуются для каждого типа контей нера. Также имеется целый ряд операций (*, ++ и другие) с итераторами, стан дартными для контейнеров.

Если итератор a указывает на некоторый элемент, то ++a указывает на следующий элемент, а *a ссылается на элемент, на который указывает a.

Объект типа iterator может использоваться для ссылки на элемент кон тейнера, который может быть модифицирован, а const_iterator для ссылки на немодифицируемый элемент контейнера.

Категории итераторов Итераторы, как и контейнеры, реализуются в виде шаблонов классов.

Итераторы обладают такими достоинствами, как, например, автоматическое от слеживание размера типа, на который указывает итератор, автоматизированные операции инкремента и декремента для перехода от элемента к элементу.

Именно благодаря таким возможностям итераторы и являются фундаментом всей библиотеки.

Итераторы можно условно разделить на две категории: основные и вспомогательные.

Основные итераторы Основные итераторы используются наиболее часто. Они взаимозаменяе мы, однако при этом нужно соблюдать иерархию старшинства (рис.8).

Итератор произвольного доступа Двунаправленный доступа Двунаправленный доступа Итератор Итератор ввода вывода Рис. 8. Иерархия итераторов Итераторы ввода. Итераторы ввода (input iterator) стоят в самом низу иерархии итераторов. Это наиболее простые из всех итераторов STL, и доступ ны они только для чтения. Итератор ввода может быть сравнен с другими ите раторами на предмет равенства или неравенства, чтобы узнать, не указывают ли два разных итератора на один и тот же объект. Можно использовать оператор разыменовывания (*) для получения содержимого объекта, на который итера тор указывает. Перемещаться от первого элемента, на который указывает ите ратор ввода, к следующему элементу можно с помощью оператора инкремента (++). Ниже приведен пример, демонстрирующий некоторые приемы работы с итератором ввода.

#include #include #include using namespace std;

main(void) { int init1[4];

vector v(4);

istream_iterator ii(cin);

for(int j,i=0;

i<4;

i++) // v.push_back(*ii++);

добавление в конец вектора // *(v.begin()+i)=*ii++;

// v[i]=*ii++;

copy(v.begin(), v.end(), ostream_iterator(cout, "\n"));

} Итераторы ввода возвращает только шаблонный класс istream_iterator.

Однако, несмотря на то что итераторы ввода возвращаются единственным клас сом, ссылки на него присутствуют повсеместно. Это связано с тем, что вместо итератора ввода может подставляться любой из основных итераторов, за ис ключением итератора вывода, назначение которого прямо противоположно итератору ввода.

template Function for_each (InputIterator first, InputIterator last, Function f) { while (first != last) f(*first++);

return f;

} В примере первые два параметра – итераторы ввода на начало цепочки объектов и на первое значение, находящееся «за пределом» для этой цепочки.

Тело алгоритма выполняет переход от объекта к объекту, вызывая для каждого значения, на которое указывает итератор ввода first, функцию. Указатель на нее передается в третьем параметре. Здесь задействованы все три перегруженных оператора, допустимые для итераторов ввода: сравнения (!=), инкремента (++) и разыменовывания (*). Ниже приводится пример использования алгоритма for_each для однонаправленных итераторов.

#include #include #include using namespace std;

void Print(int n) { cout << n << " " ;

} void main() { const int SIZE = 5 ;

typedef vector IntVector ;

// создание синонима для vector typedef IntVector::iterator IntVectorItr;

//аналогично для IntVector::iterator IntVector Numbers(SIZE) ;

//вектор, содержащий целые числа IntVectorItr start, end, it ;

// итераторы для IntVector int i ;

for (i = 0;

i < SIZE;

i++) // инициализация вектора Numbers[i] = i + 1 ;

start = Numbers.begin() ;

// итератор на начало вектора end = Numbers.end() ;

// итератор на запредельный элемент вектора for_each(start, end, Print);

cout << "\n\n" ;

} Чтобы включить в программу возможность использования потоков, до бавляется включаемый файл iostream, а для описания прототипа алгоритма for_each в программу включается заголовочный файл algorithm (algorith для продуктов Borland). Обязательным при использовании STL является использо вание директивы:

using namespace std, включающей пространство имен библиотеки STL.

Итераторы вывода. Если итератор ввода предназначен для чтения дан ных, то итератор вывода (output iterator) служит для ссылки на область памяти, куда выводятся данные. Итераторы вывода можно встретить повсюду, где про исходит хоть какая-то обработка информации средствами STL. Для данного итератора определены операторы присвоения (=), разыменовывания (*) и ин кремента (++). Однако следует помнить, что первые два оператора предполага ют, что итератор вывода располагается в левой части выражений, то есть во время присвоения он должен быть целевым итератором, которому присваива ются значения. Разыменовывание нужно делать лишь для того, чтобы присво ить некое значение объекту, на который итератор ссылается. Итераторы ввода могут быть возвращены итераторами потоков вывода (ostream_iterator) и итера торами вставки inserter, front_inserter и back_inserter (рассмотрены ниже в раз деле "Итераторы вставки"). Рассмотрим пример использования итераторов вы вода:

#include #include #include using namespace std;

main(void) { int init1[] = {1, 2, 3, 4, 5};

int init2[] = {6, 7, 8, 9, 10};

vector v(10);

merge(init1, init1 + 5, init2, init2 + 5, v.begin());

copy(v.begin(), v.end(), ostream_iterator(cout, "\n"));

} В примере помимо потоков и алгоритмов использован контейнер vector (представляющий одномерный массив, вектор). У него имеются специальные компоненты-функции begin() и end(). В приведенном нами примере создаются и инициализируются два массива – init1 и init2. Далее их значения соединяются вместе алгоритмом merge и записываются в вектор. А для проверки полученно го результата мы пересылаем данные из вектора в поток вывода, для чего вызы ваем алгоритм копирования copy и специальный итератор потока вывода ostream_iterator. Он перешлет данные в поток cout, разделив каждое пересылае мое значение символом окончания строки. Для шаблонного класса ostream_iterator требуется указать тип выводимых значений. В нашем случае это int.

Если в примере описать еще один вектор vv:

vector vv(10);

то в алгоритме copy вместо выходного итератора можно, например, использо вать итератор вектора vv для копирования данных из одного вектора в другой:

copy(v.begin(), v.end(), vv.begin());

Рассмотрим еще один пример использования итераторов ввода-вывода.

#include using namespace std;

#include #define N void main() { cout<<"Введите "<

std::istream_iterator in_obj(cin);

int ms[N],i;

for(i=0;

i

i++) { ms[i]=*in_obj;

++in_obj;

} ostream_iterator out_obj(cout);

for(i=0;

i

i++) *out_obj=ms[i];

cout<

} В инструкциях:

std::istream_iterator in_obj(cin);

и ostream_iterator out_obj(cout);

создаются итераторы istream_iterator и ostream_iterator для ввода и вывода int значений из объектов cin и cout соответственно.

Использование операции * (разыменовывания) ms[i]=*in_obj приводит к получению значения из потока in_obj и занесению его в элемент массива, а в инструкции *out_obj=ms[i] к получению ссылки на объект out_obj, ассоциируе мый с выходным потоком, и посылке значения элемента массива в поток. Пере груженная операция ++in_obj перемещает итератор in_obj к следующему эле менту во входном потоке. Отметим, что для выходного потока операции разы менование и инкремент возвращают одно значение – ссылку на поток.

ostream_iterator<_U, _E, _Tr>& operator*() {return (*this);

} ostream_iterator<_U, _E, _Tr>& operator++() {return (*this);

} Однонаправленные итераторы. Если соединить итераторы ввода и вы вода, то получится однонаправленный итератор (forward iterator), который мо жет перемещаться по цепочке объектов в одном направлении, за что и получил такое название. Для такого перемещения в итераторе определена операция ин кремента (++). Кроме этого, в однонаправленном итераторе есть операторы сравнения (== и !=), присвоения (=) и разыменовывания (*). Все эти операторы можно увидеть, если посмотреть, как реализован, например, алгоритм replace, заменяющий одно определенное значение на другое:

template void replace (ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value) { while (first != last) { if (*first == old_value) *first = new_value;

++first;

} } Чтобы убедиться в правильности работы всех операторов однонаправ ленных итераторов, составим программу, заменяющую в исходном массиве все единицы на нули и наоборот, т. е. произведем инверсию. С этой целью все нули заменяются на некоторое значение, например на двойку. Затем все единицы об нуляются, а все двойки становятся единицами:

#include #include using namespace std;

main(void) { replace(init, init + 5, 0, 2);

replace(init, init + 5, 1, 0);

replace(init, init + 5, 2, 1);

copy(init, init + 5, ostream_iterator(cout, "\n"));

} Алгоритм replace, используя однонаправленные итераторы, читает значе ния, заменяет их и перемещается от одного к другому.

Двунаправленные итераторы. Двунаправленный итератор (bidirectional iterator) аналогичен однонаправленному итератору. В отличие от последнего двунаправленный итератор может перемещаться не только из начала в конец цепочки объектов, но и наоборот. Это становится возможным благодаря нали чию оператора декремента (--). На двунаправленных итераторах базируются различные алгоритмы, выполняющие реверсивные операции, например reverse.

Этот алгоритм меняет местами все объекты в цепочке, на которую ссылаются переданные ему итераторы. Следующий пример был бы невозможен без двуна правленных итераторов:

#include #include using namespace std;

main(void) { int init[] = {1, 2, 3, 4, 5};

reverse(init, init + 5);

copy(init, init + 5, ostream_iterator(cout, "\n"));

} Итераторы двунаправленного доступа возвращаются несколькими кон тейнерами STL: list, set, multiset, map и multimap.

Итераторы произвольного доступа. Итераторы этой категории – наи более универсальные из основных итераторов. Они не только реализуют все функции, свойственные итераторам более низкого уровня, но и обладают боль шими возможностями. Глядя на исходные тексты, в которых используются ите раторы произвольного доступа, можно подумать, что имеешь дело с арифмети кой указателей языка C++. Реализованы такие операции, как сокращенное сло жение и вычитание (+= и -=), сравнение итераторов (<, >, <= и >=), операция обращения к заданному элементу массива ([]), а также и некоторые другие операции.

Как правило, все сложные алгоритмы, требующие расширенных вычис лений, оперируют итераторами произвольного доступа. Ниже приводится при мер, в котором мы используем практически все операции, допустимые для них.

Исходный текст разбит на части, к каждой из которых приведены комментарии.

Сначала нужно включить требуемые заголовочные файлы и определить кон станту пробела:

#include #include #include #define space " " Затем следует включить использование STL:

using namespace std;

В функции main мы описываем массив числовых констант и вектор из пяти элементов:

int main(void) { const int init[] = {1, 2, 3, 4, 5};

vector v(5);

Создаем переменную типа «итератор произвольного доступа». Для этого берем итератор и на его основе создаем другой, более удобный:

typedef vector::iterator vectItr;

vectItr itr ;

Инициализируем вектор значениями из массива констант и присваиваем адрес его первого элемента итератору произвольного доступа:

copy(init, init + 5, itr = v.begin());

Далее, используя различные операции над итераторами, последовательно читаем элементы вектора, начиная с конца, и выводим их на экран:

cout << *( itr + 4 ) << endl;

cout << *( itr += 3 ) << endl;

cout << *( itr -= 1) << endl;

cout << *( itr = itr - 1) << endl;

cout << *( --itr ) << endl;

После этого итератор, претерпев несколько изменений, снова указывает на первый элемент вектора. А чтобы убедиться, что значения в векторе не были повреждены, и проверить оператор доступа ([]), выведем в цикле значения век тора на экран:

for(int i = 0;

i < (v.end() - v.begin());

i++) cout << itr[i] << space;

cout << endl;

} Операции с итераторами произвольного доступа реализуются таким обра зом, чтобы не чувствовалось разницы между использованием обычных указате лей и итераторов.

Итераторы произвольного доступа возвращают такие контейнеры, как vector и deque.

Вспомогательные итераторы Вспомогательные итераторы названы так потому, что они выполняют вспомогательные операции по отношению к основным.

Реверсивные итераторы. Некоторые классы-контейнеры спроектирова ны так, что по хранимым в них элементам данных можно перемещаться в за данном направлении. В одних контейнерах это направление от первого элемен та к последнему, а в других – от элемента с самым большим значением к эле менту, имеющему наименьшее значение. Однако существует специальный вид итераторов, называемых реверсивными. Такие итераторы работают «с точно стью до наоборот», то есть если в контейнере итератор ссылается на первый элемент данных, то реверсивный итератор ссылается на последний. Получить реверсивный итератор для контейнера можно вызовом метода rbegin(), а ревер сивное значение "за пределом" возвращается методом rend(). Следующий при мер использует нормальный итератор для вывода значений от 1 до 5 и ревер сивный итератор для вывода этих же значений, но в обратном порядке:

#include #include #include using namespace std;

main(void) { const int init[] = {1, 2, 3, 4, 5};

vector v(5);

copy(init, init + 5, v.begin());

copy(v.begin(), v.end(), ostream_iterator(cout, " "));

copy(v.rbegin(), v.rend(), ostream_iterator(cout, " "));

} Итераторы потоков. Важную роль в STL играют итераторы потоков, которые делятся на итераторы потоков ввода и вывода. Практически во всех рассмотренных примерах имеется итератор потока вывода для отображения данных на экране. Суть применения потоковых итераторов в том, что они пре вращают любой поток в итератор, используемый точно так же, как и прочие итераторы: перемещаясь по цепочке данных, он считывает значения объектов и присваивает им другие значения.

Итератор потока ввода – это удобный программный интерфейс, обеспе чивающий доступ к любому потоку, из которого требуется считать данные.

Конструктор итератора имеет единственный параметр – поток ввода. А по скольку итератор потока ввода представляет собой шаблон, то ему передается тип вводимых данных. Вообще-то должно передаваться четыре типа, но по следние три имеют значения по умолчанию. Каждый раз, когда требуется вве сти очередной элемент информации, используйте оператор ++ точно так же, как с основными итераторами. Считанные данные можно узнать, если применить разыменовывание (*).

Итератор потока вывода весьма схож с итератором потока ввода, но у его конструктора имеется дополнительный параметр, которым указывают строку разделитель, добавляемую в поток после каждого выведенного элемента. Ниже приведен пример программы, читающей из стандартного потока cin числа, вводи мые пользователем и дублирующие их на экране, завершая сообщение строкой – «last entered value». Работа программы заканчивается при вводе числа 999:

#include #include #include using namespace std;

main(void) { istream_iterator is(cin);

ostream_iterator os(cout, " – введенное значение \n");

int input;

while((input = *is) != 999) { *os++ = input;

is++ ;

} } Потоковые итераторы имеют одно существенное ограничение: в них нельзя возвратиться к предыдущему элементу. Единственный способ сделать это – заново создать итератор потока.

Итераторы вставки. Появление итераторов вставки (insert iterator) было продиктовано необходимостью. Без них просто невозможно добавить значения к цепочке объектов. Так, если в массив чисел, на которые ссылается итератор вывода, вы попытаетесь добавить пару новых значений, то итератор вывода по просту запишет новые значения на место старых и они будут потеряны. Любой итератор вставки: front_inserter, back_inserter или inserter – выполнит ту же опе рацию вполне корректно. Первый из них добавляет объекты в начало цепочки, второй – в конец. Третий итератор вставляет объекты в заданное место цепоч ки. При всем удобстве итераторы вставки имеют довольно жесткие ограниче ния. Так, front_inserter и back_inserter не могут работать с наборами (set) и кар тами (map), а front_inserter к тому же не умеет добавлять данные в начало век торов (vector). Зато итератор вставки inserter добавляет объекты в любой кон тейнер. Одной интересной особенностью обладает front_inserter: данные, кото рые он вставляет в цепочку объектов, должны передаваться ему в обратном по рядке.

Рассмотрим пример программы, в которой создается список (list) с двумя значениями, равными нулю. После этого в начало и конец списка добавляются значения 1, 2, 3. Третья последовательность 1-1-1 вставляется в середину спи ска между нулями. Итак, после описания заголовочных файлов мы создаем мас сивы, необходимые для работы, и контейнер типа «список» из двух элементов:

#include #include #include using namespace std;

main(void) { int init[] = {0, 0};

int init1[] = {3, 2, 1};

int init2[] = {1, 2, 3};

int init3[] = {1, 1, 1};

list l(2);

Затем список инициализируется нулями из массива init и его значения отображаются на экране:

copy(init, init + 2, l.begin());

copy(l.begin(), l.end(), ostream_iterator(cout, " "));

cout << " – before front_inserter" << endl;

Итератором вставки в начало списка в обратном порядке добавляются значения массива init1, и производится повторный показ данных из списка на экране:

copy(init1, init1 + 3, front_inserter(l));

copy(l.begin(), l.end(), ostream_iterator(cout, " "));

cout << " – before back_inserter" << endl;

Теперь итератор вставки в конец добавит элементы массива init2 в «хвост» списка:

copy(init2, init2 + 3, back_inserter(l));

copy(l.begin(), l.end(), ostream_iterator(cout, " "));

cout << " – before inserter" << endl;

Сложнее всего обстоит дело с итератором insertes. Для него, кроме ссыл ки на сам контейнер, нужен итератор, указывающий на тот объект в контейне ре, за которым будет произведена вставка элементов массива init3. С этой це лью мы создаем переменную типа «итератор», инициализируя ее итератором, указывающим на начало списка:

list::iterator& itr = l.begin();

Теперь специальной операцией advance делаем приращение переменной итератора так, чтобы она указывала на четвертый объект в цепочке данных спи ска:

advance(itr, 4);

Остается добавить данные в цепочку посредством insertes и отобразить содержимое «списка» на дисплее:

copy(init3, init3 + 3, inserter(l, itr));

copy(l.begin(), l.end(), ostream_iterator(cout, " "));

cout << " – the end!" << endl;

} Константный итератор. Последний итератор, который мы рассмот рим, – константный (constant iterator). Он образуется путем модификации ос новного итератора. Константный итератор не допускает изменения данных, на которые он ссылается. Можно считать константный итератор указателем на константу. Чтобы получить константный итератор, можно воспользоваться ти пом const_iterator, предопределенным в различных контейнерах. К примеру, так можно описать переменную типа константный итератор на список:

list::const_iterator c_itr;

Операции с итераторами Существуют две важных операции для манипуляции ими. С одной из них – advance – мы познакомились в последнем примере. Это просто удобная форма инкрементирования итератора itr на определенное число n:

void advance (InputIterator& itr, Distance& n);

Вторая операция измеряет расстояние между итераторами first и second, возвращая полученное число через ссылку n:

void distance(InputIterator& first, InputIterator& second, Distance& n);

Контейнерные классы Контейнеры последовательностей Стандартная библиотека С++ предоставляет три контейнера последова тельностей – vector, list и deque. Первые два представляют собой классы, орга низованные по типу массивов, а последний реализует связанный список. Класс vector является одним из наиболее популярных контейнерных классов в STL, динамически изменяющим свои размеры.

Использование контейнера vector наиболее эффективно при добавлении элементов в конец контейнера. Для приложений, выполняющих частые вставки и удаления в конец и начало контейнера, более предпочтительным является deque. Если требуется выполнять вставки и удаление элементов в любое место контейнера, то обычно используется list.

Кроме перечисленных выше компонент-функций, общих для всех STL контейнеров, контейнеры последовательностей имеют несколько особых: front и back – для возврата ссылки на первый и последний элемент в контейнере, push_back и pop_back – для вставки и удаления последнего элемента контей нера.

Контейнер последовательностей vector Аналогично обычным массивам в С и С++ класс vector обеспечивает не прерывную область памяти для размещения данных. Следовательно, возможен доступ к любому элементу контейнера посредством индексации. В случае, если при добавлении новых элементов в контейнер объема выделенной памяти не достаточно, vector выделяет память большего размера. Выполняется копирова ние информации в выделенную область памяти и освобождение старой области памяти.

Контейнер vector поддерживает итераторы произвольного доступа, то есть все операции итераторов (табл. 4) могут быть применены к итератору кон тейнера vector. Все алгоритмы STL могут работать с контейнером vector.

В приводимой ниже программе демонстрируется использование некото рых компонент-функций класса vector.

#include using std::cin;

using std::cout;

using std::endl;

#include template void PrintVector(const std::vector &vect);

main() { std::vector v,vv;

PrintVector(v);

v.push_back(2);

v.push_back(5);

v.push_back(7);

v.push_back(1);

v.push_back(9);

v[4]=3;

// изменить значение 5-го элемента на v.at(3)=6;

// изменить значение 3-го элемента на try{ v.at(5)=0;

// } catch(std::out_of_range e){ //доступ к элементу вне массива (вектора) cout<<"\nИсключение : "<

} PrintVector(v);

v.erase(v.begin() + 2);

// удаление 3-го элемента (начальный индекс 0) PrintVector(v);

v.insert(v.begin() + 3,7);

// добавление 7 после 3-го элемента вектора PrintVector(v);

vv.push_back(6);

v.swap(vv);

// замена массивов v и vv PrintVector(v);

PrintVector(vv);

vv.erase(vv.begin()+1,vv.end()-2);

// удаление со 2-го по n-2 элементов PrintVector(vv);

vv.clear();

// чистка всего вектора PrintVector(vv);

return 0;

} template void PrintVector(const std::vector &vect) { std::vector::const_iterator pt;

if (vect.empty()) { cout << endl << "Vector is empty." << endl;

return;

} cout<<"ВЕКТОР :" <<" Размер ="<

for(pt=vect.begin();

pt!=vect.end();

pt++) cout<<*pt<<' ';

cout<

} Инструкция std::vector v,vv;

определяет два экземпляра класса v и vv для хранения int чисел. При этом соз даются два пустых контейнера с нулевым числом элементов и нулевой вмести мостью (числом элементов, которые могут быть сохранены в контейнере).

Компонента-функция push_back(), имеющаяся во всех контейнерах последова тельностей, используется для добавления элемента в контейнер v. Инструкции v[4]=3;

v.at(3)=6;

демонстрируют два способа индексирования контейнера vector (используются и для контейнера deque). Первая инструкция реализуется перегрузкой операции [], возвращающей либо ссылку на значение в требуемой позиции, либо кон стантную ссылку на это значение, в зависимости от того, является ли контейнер константным. Следующая функция at() выполняет то же, осуществляя дополни тельно проверку на выход индекса из диапазона. Функции size() и capacity() возвращают число элементов вектора (диапазон) и его вместимость. Вмести мость удваивается каждый раз в том случае, когда при попытке разместить оче редной элемент в контейнере все выделенное пространство памяти занято.

При добавлении первого элемента размер стал равен 1 вместимость 1, вто рого – размер 2 вместимость 2, третьего – 3 и 4 соответственно, четвертого – 4 и 8 и т.д. В примере приведена внешняя функция просмотра вектора и его разме ра и вместимости PrintVector(). Для прохода по вектору используется итератор pt:

std::vector::const_iterator pt;

Этот итератор (const_iterator) допускает считывание, но не модификацию элементов контейнера vector. При проходе по вектору используются функции begin() и end(), доступные для всех контейнеров первого класса.

Кроме перечисленных выше в программе используются функции класса vector: clear(), empty() и swap().

Контейнер vector не должен быть пустым, иначе результаты функций front и back будут не определены.

Контейнер последовательностей list Контейнерный класс list реализуется как двусвязный список, что позволя ет ему поддерживать двунаправленные итераторы для прохождения контейнера как в прямом, так и в обратном направлениях. Для контейнера list может быть использован любой алгоритм, использующий однонаправленные и двунаправ ленные итераторы. Контейнер последовательностей list эффективно реализует операции вставки и удаления в любое место контейнера.

Шаблон класса list предоставляет еще восемь функций-членов: splice, push_front, pop_front, remove, unique, merge, reverse и sort. Многие функции класса vector поддерживаются также и в классе list. Для работы с объектом (его компонентами) необходимо включать заголовочный файл .

#include using std::cout;

using std::endl;

#include template void PrintList(const std::list &lst);

main() { std::list ls,ll;

std::list::iterator itr;

int ms[]={2,5,3};

int mm[]={2,15,23,1};

ls.push_back(2);

ls.push_front(5);

ls.push_front(7);

ls.push_back(9);

PrintList(ls);

ll.insert(ll.begin(),ms,ms+sizeof(ms)/sizeof(int));

// добавление PrintList(ll);

ll.push_front(6);

ls.splice(ls.end(),ll);

PrintList(ls);

PrintList(ll);

ls.sort();

// сортировка ls PrintList(ls);

ll.insert(ll.begin(),mm,mm+sizeof(mm)/sizeof(int));

PrintList(ll);

ll.sort();

// сортировка ll ls.merge(ll);

// перенос элементов ll в ls PrintList(ls);

ls.pop_front();

// удаление первого элемента списка ls.pop_back();

// удаление последнего элемента списка ls.reverse();

// реверсивный переворот списка ls PrintList(ls);

ls.unique();

// удаление из списка ls одинаковых эл-тов PrintList(ls);

ls.swap(ll);

// обмен содержимым списков ls и ll PrintList(ls);

PrintList(ll);

ls.push_front(2);

ls.assign(ll.begin(),ll.end());

// замена ls содержимым ll PrintList(ls);

PrintList(ll);

ls.remove(2);

// удаление из ls всех PrintList(ls);

itr=ls.begin();

itr++;

ls.erase(itr,ls.end());

// удаление из ls элементов с itr до ls.end PrintList(ls);

return 0;

} template void PrintList(const std::list &lst) { std::list::const_iterator pt;

if (lst.empty()) { cout << endl << "List is empty." << endl;

return;

} cout<<"Двусвязный список = " <<" Размер = "<

cout<<" Cодержимое = ";

for(pt=lst.begin();

pt!=lst.end();

pt++) cout<<*pt<<' ';

cout<

} Рассмотрим некоторые конструкции, использованные в программе.

Используя функцию push_back (общую для всех контейнеров последова тельностей) вставки чисел в конец ls и push_front (определенную для классов list и deque) добавления значений в начало ls, создаем последовательность це лых чисел. В инструкции ll.insert(ll.begin(),ms,ms+sizeof(ms)/sizeof(int));

используется функция insert класса list, вставляющая в начало последователь ности ll элементы массива ms.

Далее в строке ls.splice(ls.end(),ll);

используется компонента-функция splice класса list, выполняющая удаление элементов списка ll с одновременным переносом их в список ls до позиции ите ратора ls.end() – первый аргумент функции. В классе list имеются две другие версии этой функции:

void splice(iterator it, list& x, iterator first);

void splice(iterator it, list& x, iterator first, iterator last);

Функция с тремя аргументами позволяет удалить один элемент из кон тейнера, определенного в качестве второго элемента, начиная с позиции, опре деленной третьим аргументом. В функции с четырьмя элементами последние два параметра определяют диапазон удаляемых из контейнера (второй пара метр) значений. Как и первая функция, два других удаляемых значения поме щают в позицию, отмеченную итератором (первый аргумент).

Выполнение инструкции ls.sort();

вызывает функцию sort() класса list, производящую упорядочивание элементов list по возрастанию.

После сортировки списков ls и ll выполняется функция ls.merge(ll);

удаляющая все объекты контейнера ll и вставки их в отсортированном виде в контейнер ls (оба списка должны быть отсортированы в одном порядке).

Далее следуют функции pop_front – удаления элемента из начала после довательности и доступная во всех контейнерах последовательности функция pop_back – удаление из конца последовательности.

В строке ls.unique();

используется функция класса list, выполняющая удаление элементов дубликатов. При этом список должен быть отсортирован.

Использование далее функции ls.swap(ll);

доступной во всех контейнерах, приводит к обмену содержимым контейнеров ls и ll.

В строке программы ls.assign(ll.begin(),ll.end());

использована функция для замены содержимого объекта ls содержимым объек та ll в диапазоне, определяемом двумя аргументами итераторами.

Строка ls.remove(2);

содержит вызов функции remove, удаляющей из ls все копии значения 2.

И, наконец, в строке ls.erase(itr,ls.end());

вызывается функция класса list, удаляющая из ls элементы с itr до ls.end.

Контейнер последовательностей deque Класс deque объединяет многие возможности классов vector и list. Этот класс представляет собой двунаправленную очередь. В классе deque реализован механизм эффективного индексного доступа (подобно тому, как и в классе vector).

Класс deque реализован для эффективных операций вставки в начало и конец. Класс deque обеспечивает поддержку итераторов прямого доступа, что дает возможность использовать при работе с ним любых алгоритмов STL.

Класс deque имеет базовые функции, аналогичные классу vector, при этом в класс deque добавлены компоненты-функции push_front и pop_front.

#include using std::cout;

using std::endl;

#include #include template void PrintDeque(const std::deque &dq);

#define SIZE main() { std::deque d,dd(3,1.5);

PrintDeque(dd);

d.push_back(2);

d.push_front(5);

d.push_back(7);

d.push_front(9);

d[4]=3;

// изменить значение 5-го элемента на d.at(3)=6;

try{ d.at(5)=0;

} catch(std::out_of_range e){ cout<<"\nИсключение : "<

} PrintDeque(d);

d.erase(d.begin() + 2);

// удаление 3-го элемента (начальный индекс 0) PrintDeque(d);

d.insert(d.begin() + 3,7);

// добавление 7 после 3-го элемента вектора PrintDeque(d);

d.insert(d.end()-1,2,1.6);

PrintDeque(d);

d.insert(d.end(),dd.begin(),dd.end());

PrintDeque(d);

std::sort(d.begin(),d.end());

PrintDeque(d);

d.swap(dd);

// замена массивов v и vv PrintDeque(d);

PrintDeque(dd);

dd.erase(dd.begin(),dd.end());

//удаление всех элементов dd PrintDeque(dd);

d.clear();

// чистка всего вектора PrintDeque(d);

return 0;

} template void PrintDeque(const std::deque &dq) { std::deque::const_iterator pt;

if (dq.empty()) { cout << endl << "Deque is empty." << endl;

return;

} cout<<"ОЧЕРЕДЬ :" <<" Размер ="<

cout<<"содержимое :";

for(pt=dq.begin();

pt!=dq.end();

pt++) cout<<*pt<<' ';

cout<

} В приведенном примере использованы все ранее рассмотренные функции классов vector и list, также являющиеся компонентами класса deque. В про грамме были использованы все три версии функции insert:

iterator insert(iterator it, const T& x = T());

void insert(iterator it, size_type n, const T& x);

void insert(iterator it, const_iterator first, const_iterator last);

Первая версия функции предназначена для вставки после элемента, на ко торый указывает итератор, значения, соответствующего второму параметру.

Вторая версия вставляет n значений, равных третьему параметру. Наконец, тре тья версия вставляет значения из интервала от второго аргумента (итератора) до третьего.

Ассоциативные контейнеры Ассоциативные контейнеры предназначены для обеспечения прямого доступа посредством использования ключей. В STL имеется четыре ассоциа тивных контейнерных класса: multiset, set, multimap и map. Во всех контейне рах ключи отсортированы. Классы multiset и set манипулируют множествами значений, одновременно являющихся ключами. При этом multiset допускает одинаковые ключи, а set нет. Классы multimap и map манипулируют множест вами значений, ассоциируемых с ключами. При этом multimap допускает хра нение одинаковых ключей с ассоциированными значениями, а map нет.

Ассоциативный контейнер multiset Ассоциативный контейнер multiset обеспечивает быстрое сохранение и выборку ключей. Упорядочение элементов контейнера определяется компара торным объектом-функцией less<тип>, при этом отсортированные ключи должны поддерживать сравнение с помощью operator<, иначе (для пользова тельских типов) необходимо перегружать операцию сравнения.

Класс multiset поддерживает двунаправленные итераторы (но не итерато ры произвольного доступа).

#include using std::cout;

using std::endl;

#include #include typedef std::multiset > intMSET;

#define size main() { int mas[]={2,4,1,6,19,17,1,7,17,14};

intMSET mset;

std::ostream_iterator out(cout," ");

intMSET::const_iterator res;

cout<<"элемент 8 содержится в multiset " << mset.count(8)<<" раз\n";

mset.insert(8);

// mset.insert(8);

cout<<"содержимое multiset :";

std::copy(mset.begin(),mset.end(),out);

res=mset.find(6);

cout<<'\n' ;

if(res!=mset.end()) cout<<"найдено значение 6\n";

else cout<<"не найдено значение 6\n";

mset.insert(mas,mas+sizeof(mas)/sizeof(int));

// cout<<"содержимое multiset :" ;

std::copy(mset.begin(),mset.end(),out);

cout<<"\nнижняя граница 17 " << *(mset.lower_bound(17));

cout<<"\nверхняя граница 17 " << *(mset.upper_bound(17));

std::pair pr;

pr=mset.equal_range(17);

cout<<"\nнижняя граница 17 " << *(pr.first);

cout<<"\nверхняя граница 17 " << *(pr.second);

return 0;

} В приведенной программе использованы следующие компоненты кон тейнерного класса multiset:

mset.count(8) – функция, доступная во всех ассоциативных контейнерах, возвращает число вхождений значения 8 в multiset. Затем в программе исполь зованы две из трех версий функции insert:

mset.insert(8);

mset.insert(mas,mas+sizeof(mas)/sizeof(int));

первая из двух функций insert вставляет значение 8 во множество, а вторая – числа из интервала.

Далее используются функции lower_bound(17) и upper_bound(17) (дос тупные во всех ассоциативных контейнерах) для определения позиции первого вхождения числа 17 во множество и позиции элемента после последнего вхож дения. Обе функции возвращают iterator или const_iterator соответствующих по зиций, или итератор, возвращаемый функцией end.

В строке std::pair pr;

создается объект класса pair. Объекты класса pair используются для связывания пар значений. Объект pr используется для сохранения в нем значения pair, воз вращаемого функцией equal_range и содержащего результаты lower_bound() и upper_bound(). Тип pair содержит две открытые компоненты с именами first и second. Для доступа к lower_bound() и upper_bound используются pr.first и pr.second.

Ассоциативный контейнер set Контейнерный класс set используется для обеспечения быстрого сохра нения и доступа к уникальным ключам. При попытке поместить в контейнер set дубликата ключа это действие игнорируется без идентификации ошибки. Кон тейнер set поддерживает двунаправленные итераторы. Работа с контейнером set может быть продемонстрирована на предыдущем примере, если в нем строку typedef std::multiset > intMSET;

заменить на строку typedef set > intMSET;

что приведет далее к созданию и работе с объектами класса set.

Ассоциативный контейнер multimap Ассоциативный контейнер multimap эффективен для быстрого сохране ния и нахождения ключей и ассоциированных с ними значений. Многие мето ды, используемые в контейнерах set и multiset, применимы к контейнерам map и multimap.

Элементами multimap и map являются объекты pair – пары ключей и со ответствующих им значений. Порядок сортировки ключей в контейнере опре деляется компараторным объектом-функцией less<тип>. В контейнере multimap допускается дублирование ключей. Это означает, что несколько зна чений могут быть ассоциированы с одним ключом (отношение ”один ко мно гим”). Например, ученик изучает много предметов, один человек может иметь несколько банковских счетов и т.д.

Контейнер multimap поддерживает двунаправленные итераторы. Для ра боты с контейнерным классом multimap необходимо подключить заголовочный файл . Рассмотрим пример использования контейнера multimap.

#include using std::cout;

using std::endl;

#include #include typedef float T1;

typedef float T2;

typedef std::multimap > MUL_MAP;

T1 key;

main() { MUL_MAP mmap,mm;

MUL_MAP::const_iterator itr;

MUL_MAP::value_type pr;

// элемент типа pair key=3.1;

cout<<"пар с ключом "<

mmap.insert(MUL_MAP::value_type(key,1.1));

mmap.insert(MUL_MAP::value_type(key,2.2));

cout<<"пар с ключом "<

mmap.insert(MUL_MAP::value_type(5,12));

mmap.insert(MUL_MAP::value_type(1,20.12));

mmap.insert(MUL_MAP::value_type(12,20.12));

mmap.erase(5);

cout<<"SIZE= "<first);

cout<<"верхняя граница "<first);

itr=mmap.find(key);

cout<<'\n' ;

if(itr!=mmap.end()) cout<<"найден ключ "<first<<'\t'<second<<'\n';

else cout<<"не найден ключ "<

mmap.clear();

return 0;

} В строках:

typedef float T1;

typedef float T2;

typedef std::multimap > MUL_MAP;

используя typedef, типам float и double назначаются псевдонимы T1 и T2 и эк земпляру шаблонного класса multimap псевдоним MUL_MAP.

Компонента-функция mmap.count(key) возвращает число пар ключа key, содержащихся в multimap. Далее следуют функции insert для ввода пар ключей и соответствующих значений в контейнер.

mmap.insert(MUL_MAP::value_type(5,12));

В этой инструкции используется функция value_type(5,12), создающая объект pair, в котором first – это ключ (5) типа T1, а second – значение (12) типа T2.

В цикле for выводится содержимое контейнерного класса multimap (клю чи и значения). Для доступа к компонентам pair элементов контейнера исполь зуется const_iterator itr. При этом ключи выводятся в порядке возрастания.

for(itr=mmap.begin();

itr!=mmap.end();

itr++) cout<first<<'\t'<second<<'\n';

Для вывода нижней и верхней границ ключа key в контейнере используются cout<<"нижняя граница "<first);

cout<<"верхняя граница "<first);

функции lower_bound() и upper_bound(), возвращающие итератор соответст вующего элемента pair.

Ассоциативный контейнер map Контейнерный класс map используется для обеспечения быстрого сохра нения и доступа к уникальным ключам и соответствующих значений. При этом между ними устанавливается взаимно однозначное соответствие. Попытка по местить в контейнер map дубликат ключа игнорируется без идентификации ошибки. Контейнер map поддерживает двунаправленные итераторы. Работа с контейнером map может быть продемонстрирована на предыдущем примере, если в нем строку typedef std::multimap > MUL_MAP;

заменить на строку typedef std:map > MUL_MAP;

что приведет далее к созданию и работе с объектами класса map.

Адаптеры контейнеров В состав STL входят три адаптера контейнеров – stack, queue и priority_queue. Адаптеры не предоставляют реализации фундаментальной структуры данных и не поддерживают работу с итераторами. Это отличает их от контейнеров первого класса. Преимущество класса адаптеров состоит в воз можности выбирать требуемую базовую структуру данных. Все три класса адаптеров содержат компоненты-функции push и pop, реализуемые посредст вом вызова соответствующих функций базового класса.

Адаптеры stack Класс stack обеспечивает возможность вставки и удаления данных в ба зовой структуре с одной стороны. Адаптер stack может быть реализован с лю бым из контейнеров последовательностей: vector, list и deque (по умолчанию реализуется с контейнером deque). Для класса stack определены следующие операции (реализуемые через соответствующие функции базового контейнера):

push – помещение элемента на вершину стека, pop – удаление элемента с вер шины стека, top – получение ссылки на вершину стека, empty – проверки на пустоту стека и size – получение числа элементов стека.

#include using std::cout;

using std::endl;

#include #include #include typedef char T;

template void popElement(E &e) { while(!e.empty()) // пока стек не пустой { cout<

// получение значения элемента на вершине стека e.pop();

// удаление элемента с вершины стека } } main() { std::stack deque_st;

// стек на основе deque std::stack > vect_st;

// стек на основе vector std::stack > list_st;

// стек на основе list char c='a';

for(int i=0;

i<5;

i++) // занесение в стеки { deque_st.push(c++);

vect_st.push(c++);

list_st.push(c++);

} cout << "\nСтек deque :";

popElement(deque_st);

cout << "\nСтек vector :";

popElement(vect_st);

cout << "\nСтек list :";

popElement(list_st);

cout<

return 0;

} Результат работы программы:

Стек deque : m j g d a Стек vector : n k h e b Стек list : o l i f c В первых трех строках функции main создаются три стека для хранения символов, использующие в качестве базовых структур контейнеры deque (по умолчанию), vector и list соответственно. Далее в программе использована функция push для помещения элементов на вершину соответствующего стека.

Реализованная в программе template функция выводит на экран удаляе мый с вершины стека элемент. Для этого использованы функции top – нахож дения (но не удаления) элемента на вершине стека и pop – удаления его с вер шины стека.

Адаптеры queue Класс queue предназначен для вставки элементов в конец базовой структуры данных и удаления элементов из ее начала. Адаптер queue реализуется с контейнерами list и deque (по умолчанию).

Наряду с общими для всех классов адаптеров операциями push, pop, empty и size в классе queue имеются операции front – получения ссылки на первый элемент очереди, back – ссылки на последний элемент очереди.

#include using std::cout;

using std::endl;

#include // #include для базового контейнера list typedef int T;

main() { std::queue och;

// std::queue > lst;

очередь на основе контейнера list och.push(1);

// занесение в очередь och.push(2);

och.push(3);

int k=och.size();

// количество элементов в очереди cout << "Очередь : ";

if(och.empty()) cout<<" пустая";

// проверка на пустоту очереди else { for(int i=0;

i

i++) { cout<

// вывод значения первого элемента очереди och.pop();

// удаление из очереди первого элемента } } cout<

return 0;

} Результат работы программы:

Очередь : 1 2 Инструкция std::queue och;

создает очередь для хранения в ней значений типа T. Очередь создается на ос нове контейнера deque по умолчанию. Функция front считывает значение пер вого элемента очереди, не удаляя его из нее. Для этого используется функция pop.

Адаптеры priority_queue Класс priority_queue используется для вставки элементов в отсортиро ванном порядке в базовую структуру данных и удаления элементов из ее нача ла. Адаптер priority_queue реализуется с контейнерами vector (по умолчанию) и deque.

Элементы в очередь с приоритетом заносятся в соответствии со своим значением. Это означает, что элемент с максимальным значением помещается в начало очереди и будет первым из нее удален, а с минимальным – в конец оче реди. Это достигается с помощью метода, называемого сортировкой кучи.

Сравнение элементов выполняется функцией-объектом less<Тип> или другой компораторной функцией.

Как и предыдущие адаптеры, priority_queue использует операции push, pop, empty, size, а также операцию top – получения ссылки на элемент с наи высшим приоритетом.

Пассивные и активные итераторы Можно определять итерацию как часть объекта или создавать отдельные объекты, ответственные за итеративный опрос других структур. К достоинст вам второго подхода относятся:

– наличие выделенного итератора классов, позволяющего одновременно проводить несколько просмотров одного и того же объекта;

– наличие итерационного механизма в самом классе, что несколько нару шает его инкапсуляцию, выделение итератора в качестве отдельного механизма поведения способствует достижению большей ясности в описании класса.

Для каждой структуры определены две формы итераций. Активный ите ратор требует каждый раз от клиента явного обращения к себе для перехода к следующему элементу. Пассивный итератор применяет функцию, предостав ляемую клиентом, и, таким образом, требует меньшего вмешательства клиента.

С целью обеспечения безопасности типов для каждой структуры создаются свои итераторы.

template class ActivIterator { public:

ActivIterator (const Queue&);

~ActivIterator();

void reset();

int next();

int isDone() const;

const Item* currentItem() const;

protected:

const Queue& queue;

int index;

};

Каждому итератору ставится в соответствие определенный объект.

Используя функцию currentItem(), клиент может получить доступ к теку щему элементу. Если итерация завершена или последовательность структур пуста, то возвращается нулевое значение. Переход к следующему элементу по следовательности выполняется функцией next(), возвращающей 0, если итера ция завершена. Функция isDone() возвращает информацию о состоянии процес са (0 – если итерация завершена или структура пуста). Функция reset() позволя ет осуществлять неограниченное число итерационных проходов по объекту.

Например, при наличии объявления:

BoundedQueue eventQueue;

Фрагмент кода, использующий активный итератор для прохода по элементам очереди, будет выглядеть так:

QueueActiveIterator iter(eventQueue);

while(!iter.isDone()) { iter.currentItem()->dispatch();

iter.next();

} Конструктор класса QueueActiveIterator сначала устанавливает связь меж ду итератором и конкретной очередью. Затем вызывается защищенная функция cardinality, которая определяет количество элементов в очереди. Конструктор может иметь вид:

template QueueActiveIterator ::QueueActiveIterator(const Queue& q) :queue(q), index(q,cardinality()? 0 :

-1;

) {} Класс QueueActiveIterator имеет доступ к защищенной функции cardinality класса Queue, являясь дружественным ему.

Операция итератора isDone проверяет принадлежность текущего индекса допустимому диапазону, определяемому количеством элементов очереди.

template int QueueActiveIterator ::isDone() const { return((index<0 || (index>=queue.cardinality()));

} Функция currentItem возвращает указатель на элемент, на котором оста новился итератор. Реализация итератора в виде индекса объекта в очереди дает возможность в процессе итерации добавлять и удалять элементы из очереди.

template const Item* QueueActiveIterator ::currentItem() const { return isDone()? 0 : &queue.itemAt(index);

} При выполнении операции итератор вновь вызывает защищенную функ цию itemAt. Операция next имеет вид:

template int QueueActiveIterator ::next() { index++;

return !isDone();

} Пассивный итератор, который также называют аппликатором, характеризуется тем, что он применяет определенную функцию к каждому элементу структуры. Для класса Queue пассивный итератор можно определить следующим образом:

template class QueuePassiveIterator {public:

QueuePassiveIterator(const Queue&);

~QueuePassiveIterator();

int apply(int (*) (const Item&));

protected:

const Queue& queue };

Пассивный итератор действует на все элементы структуры за (логически) одну операцию. Таким образом, функция apply() последовательно производит одну и ту же операцию над каждым элементом структуры, пока передаваемая итератору функция не возвратит нулевое значение или пока не будет достигнут конец структуры. В первом случае функция apply() сама возвратит нулевое значение в знак того, что итерация не была завершена.

Алгоритмы Более ранние библиотеки контейнеров для реализации алгоритмов обыч но использовали наследование и полиморфизм, что влекло за собой потерю производительности, связанную с вызовом виртуальных функций. Алгоритмы были встроены в контейнерные классы. В STL алгоритмы отделены от контей неров, что упрощает расширение их числа. Доступ к элементам контейнеров в STL осуществляется посредством итераторов. STL-алгоритмы используют ите раторы в качестве аргументов (наряду с этим STL-алгоритмы также могут рабо тать с любыми массивами языка С на основе указателей).

Каждый алгоритм использует итераторы определённого типа. Например, алгоритм простого поиска (find) просматривает элементы подряд, пока нужный не будет найден. Для такой процедуры вполне достаточно итератора ввода. С другой стороны, алгоритм более быстрого двоичного поиска (binary_search) должен иметь возможность переходить к любому элементу последовательности и поэтому требует итератора с произвольным доступом. Вполне естественно, что вместо менее функционального итератора можно передать алгоритму более функциональный, но не наоборот.

Все стандартные алгоритмы описаны в заголовочном файле algorithm, в пространстве имён std.

Ниже при описании прототипов некоторых алгоритмов будем использо вать следующие обозначения итераторов:

OutIt – iterator вывода;

InIt – iterator ввода;

FwdIt – однонаправленный iterator;

BidIt – двунаправленный iterator;

RanIt – iterator прямого доступа.

Алгоритмы сортировки sort, partial_sort, sort_heap Для сортировки данных в STL имеются различные алгоритмы. Рассмот рим некоторые из них.

Алгоритм sort является алгоритмом обычной сортировки, единственным ограничением которого является то, что он используется для контейнеров, под держивающих итераторы произвольного доступа. Прототипы функции sort приведены ниже.

template void sort(RanIt first, RanIt last);

template void sort(RanIt first, RanIt last, Pred pr);

Действие первого из них основано на использовании перегруженной опе рации opepator<() для сортировки данных по возрастанию. Второй вариант за меняет операцию сравнения функцией сравнения pr(x,y), тем самым позволяя сортировать данные в порядке, определяемом пользователем.

#include #include #include using namespace std;

void Print(int x) { cout << x <<' ';

} int main() { vector v(4);

v[0] = 3;

v[1] = 1;

v[2] = 5;

v[3] = 2;

sort(v.begin(), v.end() );

for_each(v.begin(), v.end(), Print);

return 0;

} Результатом работы программы будет массив 1 2 3 Использованный в программе алгоритм for_each полезен тогда, когда на до произвести перебор всех элементов контейнера и выполнить некоторое дей ствие для каждого из них.

Для использования алгоритма sort с тремя параметрами требуется в каче стве третьего аргумента использовать указатель на функцию или функциональ ный объект. Например, для сортировки в обратном порядке требуется включить заголовок:

sort(v.begin(), v.end(), greater() );

Алгоритм partil_sort предназначен для сортировки только части массива.

Алгоритм sort_heap предназначен для сортировки накопителя.

Алгоритмы поиска find, find_if, find_end, binary_search В STL имеется несколько алгоритмов, выполняющих поиск в контейнере.

Приводимая ниже программа демонстрирует возможности этих алгоритмов.

#include #include #include #define T int using namespace std;

bool fun(T i){return i%2==0;

} int main() { T m1[]={5,3,4,7,3,12};

std::vector v1(m1,m1+sizeof(m1)/sizeof(T));

std::ostream_iterator out(cout," ");

std::vector::iterator itr;

cout<<"вектор v1 : ";

std::copy(v1.begin(),v1.end(),out);

itr=std::find(v1.begin(),v1.end(),5);

cout<<"\nзначение 5 ";

if(itr!=v1.end()) cout<<"найдено в позиции "<

else cout<<"не найдено\n";

itr=std::find_if(v1.begin(),v1.end(),fun);

if(itr!=v1.end()) cout<<"первый четный элемент вектора v1["<< itr-v1.begin()<<"]= "<<*itr<

else cout<<"четные элементы в векторе v1 отсутствуют\n";

// std::sort(v1.begin(),v1.end());

// необходимо выполнить if(std::binary_search(v1.begin(),v1.end(),3)) // сортировку вектора cout<<"число 3 найдено в векторе v1\n";

// для binary_search else cout<<"число 3 не найдено в векторе v1\n";

return 0;

} В приведенной программе использован алгоритм find, выполняющий по иск в векторе v1 значения 5.

itr=std::find(v1.begin(),v1.end(),5);

Далее в программе использована функция find_if нахождения первого значения вектора v, для которого унарная предикатная функция fun возвращает true:

itr=std::find_if(v1.begin(),v1.end(),fun);

Каждый из алгоритмов find и find_if возвращает итератор ввода на най денный элемент либо (если элемент не найден) итератор, равный v.end(). Аргу менты find и find_if должны быть, по крайней мере, итераторами ввода.

В строке:

if(std::binary_search(v1.begin(),v1.end(),3)) для поиска значения 3 в векторе v1 использована функция binary_search. При этом последовательность элементов вектора в анализируемом диапазоне долж на быть отсортирована в возрастающем порядке. Функция возвращает значение bool. В STD имеется вторая версия алгоритма binary_search, имеющая четвер тый параметр, – бинарная предикатная функция, возвращающая true, если два сравниваемых элемента упорядочены.

Алгоритмы fill, fill_n, generate и generate_n Алгоритмы данной группы предназначены для заполнения определенным значением некоторого диапазона элементов контейнера. При этом алгоритмы generate и generate_n используют порождающую функцию. Порождающая функция не принимает никаких аргументов и возвращает значение, заносимое в элемент контейнера.

Прототип функций fill, fill_n имеет вид:

template void fill(FwdIt first, FwdIt last, const T& x);

template void fill_n(OutIt first, Size n, const T& x);

Пример программы, использующей алгоритм generate, приведен ниже.

#include #include #include using namespace std;

// функция нахождения чисел Фибоначчи int Fibonacci(void) { static int r;

static int f1 = 0;

static int f2 = 1;

r = f1 + f2 ;

f1 = f2 ;

f2 = r ;

return f1 ;

} void main() { const int v_size = 8 ;

typedef vector vect;

typedef vect::iterator vectIt ;

vect numb(v_size);

// вектор, содержащий числа vectIt start, end, it ;

start = numb.begin() ;

// позиция первого элемента end = numb.end() ;

// позиция последнего эл-та // заполнение [first, last +1) числами Фибоначчи // используя функцию Fibonacci() generate(start, end, Fibonacci) ;

cout << "numb { " ;

// вывод содержимого for(it = start;

it != end;

it++) cout << *it << " " ;

cout << " }\n" << endl ;

} Алгоритмы equal, mismatch и lexicographical_compare Алгоритмы данной группы используются для выполнения сравнения на равенство последовательностей значений.

#include #include #include using namespace std;

int main() { int m1[]={2,3,5,7,12};

int m2[]={2,3,55,7,12};

std::vector v1(m1,m1+sizeof(m1)/sizeof(int)), v2(m2,m2+sizeof(m2)/sizeof(int)), v3(m1,m1+sizeof(m1)/sizeof(int));

bool res=equal(v1.begin(), v1.end(),v2.begin());

cout<<"\nВектор v1 "<<(res?"":" не ")<<" равен вектору v2";

res=equal(v1.begin(), v1.end(),v3.begin());

cout<<"\nВектор v1 "<<(res?"":" не ")<<" равен вектору v3";

std::pair::iterator, std::vector::iterator> pr;

pr=std::mismatch(v1.begin(), v1.end(),v2.begin());

cout<<"\nv1 и v2 имеют различие в позиции " <<(pr.first-v1.begin())<<" где v1= "<<*pr.first <<" а v2= "<<*pr.second<<'\n';

char s1[]="abbbw", s2[]="hkc";

res=std::lexicographical_compare(s1,s1+sizeof(s1)/sizeof(char), s2,s2+sizeof(s2)/sizeof(char));

cout<

return 0;

} В строке bool res=equal(v1.begin(), v1.end(),v2.begin());

для сравнения двух последовательностей чисел на равенство используется ал горитм equal, получающий в качестве аргументов три итератора (по крайней мере для чтения). Если последовательности неравной длины или их элементы не совпадают, то equal возвращает false (используя функцию operator==).

Имеется также версия equal, принимающая четвертым параметром преди катную функцию, получающую два сравниваемых элемента и возвращающую значение типа bool. Это может быть полезно для последовательностей объектов или указателей на сравниваемые значения.

Алгоритм mismatch возвращает пару итераторов для двух сравниваемых последовательностей (v1 и v2), указывающих позиции, где элементы различа ются:

std::pair::iterator, std::vector::iterator> pr;

pr=std::mismatch(v1.begin(), v1.end(),v2.begin());

Для определения позиции, в которой векторы различаются, требуется вы полнить pr.first-v1.begin(). Согласно арифметике указателей это соответствует числу элементов от начала вектора v1 до элемента, отличного от соответст вующего элемента вектора v2.

Алгоритм lexicographical_compare использует четыре итератора (по крайней мере для чтения) для сравнения, обычно строк. Если элемент первой последовательности (итерируемый первыми двумя итераторами) меньше эле мента второй (два последних итератора), то функция возвращает true, иначе false.

Математические алгоритмы Приводимая ниже программа демонстрирует использование нескольких математических алгоритмов: random_shuffle, count, count_if, min_element, max_element, accumulate и transform.

#include #include #include #include using namespace std;

// возвращает целое число в диапазоне 0 – (n – 1) int Rand(int n) { return rand() % n ;

} void main() { const int v_size = 8 ;

typedef vector vect;

typedef vect::iterator vectIt ;

vect Numbers(v_size) ;

vectIt start, end, it ;

// инициализация вектора Numbers[0] = 4 ;

Numbers[1] = 10;

Numbers[2] = 70 ;

Numbers[3] = 4 ;

Numbers[4] = 10;

Numbers[5] = 4 ;

Numbers[6] = 96 ;

Numbers[7] = 100;

start = Numbers.begin() ;

// location of first end = Numbers.end() ;

// one past the location cout << "До выполнения random_shuffle:" << endl ;

cout << "Numbers { " ;

for(it = start;

it != end;

it++) cout << *it << " " ;

cout << " }" << endl ;

random_shuffle(start, end,pointer_to_unary_function(Rand));

cout << "После выполнения random_shuffle:" << endl ;

cout << "Numbers { " ;

for(it = start;

it != end;

it++) cout << *it << " " ;

cout << " }" << endl ;

cout<<"число 4 встречается"<

} Результат работы программы:

До выполнения random_shuffle Numbers {4 10 70 4 10 4 96 100} После выполнения random_shuffle Numbers {10 4 4 70 96 100 4 10} число 4 встречается 3 раза Кратко охарактеризуем данные алгоритмы:

random_shuffle – имеется две версии функции для расположения в произ вольном порядке чисел в диапазоне, определяемом аргументами-итераторами;

count, count_if – используются для подсчета числа элементов с заданным значением в диапазоне;

min_element, max_element – нахождение min- и max- элемента в диапазоне;

accumulate – суммирование чисел в диапазоне;

transform – применение общей функции к каждому элементу вектора.

Алгоритмы работы с множествами Манипуляция множествами отсортированных значений выполняется ал горитмами: includes, set_difference, set_intersection, set_symmetric_difference и set_union. Приводимая ниже программа показывает пример использования алгоритма includes, проверяющего, входят ли элементы последовательности Deque в вектор Vector.

#include #include #include #include #include #include using namespace std;

void main() { const int VECTOR_SIZE = 5 ;

vector Vector(VECTOR_SIZE) ;

vector::iterator start1, end1, it1;

deque Deque ;

deque::iterator start2, end2, it2 ;

Vector[0] = "Коля";

// инициализация вектора Vector[1] = "Аня";

Vector[2] = "Сергей";

Vector[3] = "Саша";

Vector[4] = "Вася";

start1 = Vector.begin() ;

// итератор на начало Vector end1 = Vector.end() ;

// итератор на конец Vector Deque.push_back("Сергей") ;

// инициализация последовательности Deque.push_back("Аня") ;

Deque.push_back("Саша") ;

start2 = Deque.begin() ;

// итератор на начало Deque end2 = Deque.end() ;

// итератор на конец Deque sort(start1, end1) ;

//сортировка Vector и Deque sort(start2, end2) ;

// вывод содержимого Vector и Deque cout << "Vector { " ;

for(it1 = start1;

it1 != end1;

it1++) cout << *it1 << ", " ;

cout << " }\n" << endl ;

cout << "Deque { " ;

for(it2 = start2;

it2 != end2;

it2++) cout << *it2 << ", " ;

cout << " }\n" << endl ;

if(includes(start1, end1, start2, end2) ) cout << "Vector включает Deque" << endl ;

else cout << "Vector не включает Deque" << endl ;

} Несколько слов о других алгоритмах:

set_difference – определяются элементы из первого множества, не входящие во второе;

set_intersection – противоположный предыдущему алгоритму;

set_symmetric_difference – выделяются элементы, которые содержатся только в одном из двух множеств;

set_union – объединение двух множеств в одно.

Алгоритмы swap, iter_swap и swap_ranges Данная группа алгоритмов предназначена для выполнения перестановки элементов контейнера. Ниже приведены прототипы данных алгоритмов:

template void swap(const vector & lhs,const vector & rhs);

Аргументами алгоритма swap являются ссылки на элементы для замены template void iter_swap(FwdIt1 x, FwdIt2 y);

Аргументами алгоритма являются два прямых итератора на элементы.

template FwdIt2 swap_ranges(FwdIt1 first, FwdIt1 last, FwdIt2 x);

алгоритм swap_ranges используется для перестановки элементов от first до last с элементами начиная с х.

Все указанные замены производятся в одном и том же контейнере.

Алгоритмы copy, copy_backward, merge, unique и reverse Дадим краткую характеристику алгоритмам копирования:

copy_backward – используется для копирования элементов из одного век тора в другой;

merge – используется для объединения двух отсортированных последова тельностей в третью;

unique – исключает дублирование элементов в последовательности;

reverse – используется для перебора элементов в обратном порядке.

Примеры реализации контейнерных классов Связанные списки Связанные списки – это способ размещения данных, при котором одни данные ссылаются на другие. Списки представляют собой пример контейнер ных классов. В общем, список напоминает массив с тем отличием, что его раз меры не фиксированы: он может расти и уменьшаться по мере работы с ним.

Очередной элемент списка размещается в памяти динамически и связывается с остальной частью списка посредством указателей. В случае если некоторый элемент списка более не нужен, то освобождается память, отведенная под этот элемент. Частным случаем списков являются стеки, очереди и кольца.

Реализация односвязного списка Односвязный список предполагает организацию хранения данных в па мяти, при которой перемещение может быть выполнено только в одном на правлении (от начала списка в конец). Расположение в памяти элементов одно связного списка можно изобразить следующим образом (рис. 9).

Голова Эл-т вне списка Рис. 9. Односвязный список В настоящем пособии реализация односвязного списка не приводится (предлагается выполнить самостоятельно, основываясь на информации о реализации двусвязного списка, приводимого ниже).

Реализация двусвязного списка Двусвязный список – это организация хранения данных в памяти, позво ляющая выполнять перемещение в обоих направлениях (от начала списка в ко нец и наоборот). Расположение в памяти двусвязного списка можно изобразить следующим образом (рис. 10).

Голова Эл-т вне списка Рис. 10. Двусвязный список В приведенном ниже примере для доступа к элементам списка использу ется разработанный класс, реализующий простые итераторы.

#include #include using namespace std;

template class D_List {private:

class D_Node { public:

D_Node *next;

// указатель на следующий узел D_Node *prev;

// указатель на предыдущий узел T val;

// поле данного D_Node(T node_val) : val(node_val) { } // конструктор D_Node() {} // конструктор ~D_Node(){} // деструктор // для вывода элементов, тип которых определен пользователем, // неодходимо перегрузить операцию << operator<<( ).

void print_val( ) { cout << val << " ";

} };

public:

class iterator {private:

friend class D_List;

D_Node * the_node;

public:

iterator( ) : the_node(0) { } iterator(D_Node * dn) : the_node(dn) { } // Copy constructor iterator(const iterator & it) : the_node(it.the_node) { } iterator& operator=(const iterator& it) { the_node = it.the_node;

return *this;

} bool operator==(const iterator& it) const { return (the_node == it.the_node);

} bool operator!=(const iterator& it) const { return !(it == *this);

} iterator& operator++( ) { if ( the_node == 0 ) throw "incremented an empty iterator";

if ( the_node->next == 0 ) throw "tried to increment too far past the end";

the_node = the_node->next;

return *this;

} iterator& operator--( ) { if ( the_node == 0 ) throw "decremented an empty iterator";

if ( the_node->prev == 0 ) throw "tried to decrement past the beginning";

the_node = the_node->prev;

return *this;

} T& operator*( ) const { if ( the_node == 0 ) throw "tried to dereference an empty iterator";

return the_node->val;

} };

private:

D_Node *head;

// указатель на начало списка D_Node *tail;

// указатель на элемент вне списка D_List & operator=(const D_List &);

D_List(const D_List &);

iterator head_iterator;

iterator tail_iterator;

public:

D_List( ) { head = tail = new D_Node;

tail->next = 0;

tail->prev = 0;

head_iterator = iterator(head);

tail_iterator = iterator(tail);

} // конструктор (создание списка, содержащего один элемент) D_List(T node_val) { head = tail = new D_Node;

tail->next = 0;

tail->prev = 0;

head_iterator = iterator(head);

tail_iterator = iterator(tail);

add_front(node_val);

} // деструктор ~D_List( ) { D_Node *node_to_delete = head;

for (D_Node *sn = head;

sn != tail;

) { sn = sn->next;

delete node_to_delete;

node_to_delete = sn;

} delete node_to_delete;

} bool is_empty( ) {return head == tail;

} iterator front( ) { return head_iterator;

} iterator rear( ) { return tail_iterator;

} void add_front(T node_val) { D_Node *node_to_add = new D_Node(node_val);

node_to_add->next = head;

node_to_add->prev = 0;

head->prev = node_to_add;

head = node_to_add;

head_iterator = iterator(head);

} // добавление нового элемента в начало списка void add_rear(T node_val) { if ( is_empty( ) ) // список не пустой add_front(node_val);

else // не выполняется для пустого списка, т.к. tail->prev =NULL // и, следовательно, tail->prev->next бессмысленно { D_Node *node_to_add = new D_Node(node_val);

node_to_add->next = tail;

node_to_add->prev = tail->prev;

tail->prev->next = node_to_add;

tail->prev = node_to_add;

tail_iterator = iterator(tail);

} } bool remove_it(iterator & key_i) { for ( D_Node *dn = head;

dn != tail;

dn = dn->next ) if ( dn == key_i.the_node ) // найден узел для удаления { dn->prev->next = dn->next;

dn->next->prev = dn->prev;

delete dn;

// удаление узла key_i.the_node = 0;

return true;

} return false;

} // поиск итератора по значению узла iterator find(T node_val) const { for ( D_Node *dn = head;

dn != tail;

dn = dn->next ) if ( dn->val == node_val ) return iterator(dn);

return tail_iterator;

} int size( ) const { int count = 0;

for ( D_Node *dn = head;

dn != tail;

dn = dn->next ) ++count;

return count;

} // Вывод содержимого списка void print( ) const { for ( D_Node *dn = head;

dn != tail;

dn = dn->next ) dn->print_val( );

cout << endl;

} };

В файле d_list.cpp содержится main-функция, демонстрирующая некоторые примеры работы со списком.

#include "dlist_2.h" typedef int tip;

D_List the_list;

// создается пустой список int main() { int ret = 0;

D_List::iterator list_iter;

// занесение значений 0 1 2 3 4 в список for (int j = 0;

j < 5;

++j) the_list.add_front(j);

// вывод содержимого списка используя компоненту-функцию // класса D_List the_list.print( );

// повторный вывод значения содержимого списка // используя итератор for ( list_iter = the_list.front( ) ;

list_iter != the_list.rear( ) ;

++list_iter ) cout << *list_iter << " ";

cout << endl;

// вывод содержимого списка в обратном порядке for ( list_iter = the_list.rear( ) ;

list_iter != the_list.front( ) ;

) { --list_iter;

// декремент итератора cout << *list_iter << " ";

} cout << endl;

the_list.remove_it(the_list.find(3));

the_list.print( );

cout<

return 0;

} Результат работы программы:

3 2 1 3 2 1 0 1 2 3 2 1 Итератор реализован как открытый вложенный класс D_List::iterator. Так как класс открытый, может быть в main создан его объект. Класс iterator объяв ляет дружественным классу D_List, чтобы функция remuv_it класа D_List име ла возможность обращаться к private-члену the_node класса iterator.

В дополнение к стандартным указателям на голову и хвост списка (адрес за пределами списка) в программе (в d_list.h) объявлены итераторы head_iterator и tail_iterator, также ссылающиеся на голову и хвост списка.

Использование итератора позволяет скрыть единственный элемент дан ных класса D_List:

D_Node * the_node.

В классе iterator выполнена перегрузка некоторых операций, позволяю щих манипулировать узлом в строго определенных правилах (табл. 5).

Таблица Функция Описание operator=() Присваивает the_node значение the_node правой части operator==() Возвращает true, если оба итератора ссылаются на один узел operator!=() Отрицание операции == operator++() Перемещает итератор на следующий узел operator--() Перемещает итератор на предыдущий узел operator*() Возвращает значение node_val узла D_node Для поддержки использования итераторов в качестве аргументов или воз вращаемых значений определен конструктор копирования.

В программе функция find(T) возвращает не bool, а iterator, который мо жет быть передан другим функциям, принимающим параметры-итераторы, для доступа к данным или прохода по списку.

Использование итераторов позволяет пользователю манипулировать спи ском, при этом детали его реализации остаются надежно скрытыми.

Реализация двоичного дерева В отличие от списков двоичные деревья представляют собой более слож ные структуры данных.

Дерево – непустое конечное множество элементов, один из которых на зывается корнем, а остальные делятся на несколько непересекающихся под множеств, каждое из которых также является деревом. Одним из разновидно стей деревьев являются бинарные деревья. Бинарное дерево имеет один ко рень и два непересекающихся подмножества, каждое из которых само является бинарным деревом. Эти подмножества называются левым и правым подде ревьями исходного дерева. На рис. 11 приведены графические изображения бинарных деревьев. Если один или более узлов дерева имеют более двух ссы лок, то такое дерево не является бинарным.

B D A F B F D G A C E G C E б а Рис. 11. Структура бинарного дерева Бинарные деревья с успехом могут быть использованы, например, при сравнении и организации хранения очередной порции входной информации с информацией, введенной ранее, и при этом в каждой точке сравнения может быть принято одно из двух возможных решений. Так как информация вводится в произвольном порядке, то нет возможности предварительно упорядочить ее и применить бинарный поиск. При использовании линейного поиска время про порционально квадрату количества анализируемых слов. Каким же образом, не затрачивая большое количество времени, организовать эффективное хранение и обработку входной информации. Один из способов постоянно поддерживать упорядоченность имеющейся информации – это перестановка ее при каждом новом вводе информации, что требует существенных временных затрат.

Построение бинарного дерева осуществляется на основе лексикографического упорядочивания входной информации.

Лексикографическое упорядочивание информации в бинарном дереве заключается в следующем. Считывается первая информация и помещается в узел, который становится корнем бинарного дерева с пустыми левым и правым поддеревьями. Затем каждая вводимая порция информации сравнивается с ин формацией, содержащейся в корне. Если значения совпадают, то, например, на ращиваем число повторов и переходим к новому вводу информации. Если же введенная информация меньше значения в корне, то процесс повторяется для левого поддерева, если больше – для правого. Так продолжается до тех пор, по ка не встретится дубликат или пока не будет достигнуто пустое поддерево. В этом случае число помещается в новый узел данного места дерева.

Приводимый далее пример шаблонного класса B_tree демонстрирует про стое дерево поиска. Как и для программы очереди, код программы организован в виде двух файлов, где файл Bt.h является непосредственно шаблонным клас сом дерева, а Bt.cpp демонстрирует работу функций шаблонного класса. Внача ле приведен текст файла Bt.h.

#include #include using namespace std;

/////////////////////////////////////////////////////////////// // реализация шаблона класса B_tree // Тип Т должен поддерживать следующие операции:

// operator=( );

// operator<<( );

// operator==( );

// operator!=( );

// operator<( );

// /////////////////////////////////////////////////////////////// template class B_tree { private:

struct T_node { friend class B_tree;

T val;

// данные узла T_node *left;

// указатель на левый узел T_node *right;

// указатель на правый узел int count;

// число повторов val при вводе T_node();

// конструктор T_node( const T node_val ) : val(node_val) { } // конструктор ~T_node(){} // деструктор // печать данных в виде дерева "на боку" с корнем слева // "Обратный" рекурсивный обход (т.е. справа налево) // Листья показаны как "@".

void print ( const int level = 0 ) const { // Инициализация указателем this (а не корнем) // это позволяет пройти по любому поддереву const T_node *tn = this;

if(tn) tn->right->print(level+1);

// сдвиг вправо до листа for (int n=0;

n

++n) cout << " ";

if(tn) cout << tn->val << '(' << tn->count << ')' << endl;

else cout << "@" << endl;

if(tn) tn->left->print(level+1);

// сдвиг на левый узел } };

private:

T_node *root;

T_node *zero_node;

// Запретить копирование и присваивание B_tree(const B_tree &);

B_tree & operator=( const B_tree & );

// Создать корневой узел и проинициализировать его void new_root( const T root_val ) { root = new T_node(root_val);

root->left = 0;

root->right = 0;

root->count = 1;

} // Find_node(T find_value) возвращает ссылку на // указатель для упрощения реализации remove(T).

T_node * & find_node( T find_value ) { T_node *tn = root;

while ((tn != 0) && (tn->val != find_value)) { if(find_value < tn->val) tn = tn->left;

// движение налево else tn = tn->right;

// движение направо } if (!tn) return zero_node;

else return tn;

} // Присоединяет новое значение ins_val к соответствующему листу, // если значения нет в дереве, и увеличивает count для каждого // пройденного узла T_node * insert_node( const T ins_val, T_node * tn = 0 ) { if(!root) { new_root(ins_val);

return root;

} if(!tn) tn = root;

if((tn ) && (tn->val != ins_val)) { if(ins_val < tn->val) { if(tn->left) // просмотр левого поддерева insert_node(ins_val,tn->left);

else { attach_node(tn,tn->left,ins_val);

// вставка узла return tn->left;

} } else { if(tn->right) // просмотр правого поддерева insert_node(ins_val,tn->right);

else { attach_node(tn,tn->right,ins_val);

// вставка узла return tn->right;

} } } else if(tn->val==ins_val) add_count(tn,1);

assert(tn);

// Оценивает выражение и, когда результат ЛОЖЕН, печатает // диагностическое сообщение и прерывает программу return 0;

} // Создание нового листа и его инициализация void attach_node( T_node * new_parent, T_node * & new_node, T insert_value ) { new_node = new T_node( insert_value );

new_node->left = 0;

new_node->right = 0;

new_node->count = 1;

} // Увеличение числа повторов содержимого узла void add_count( T_node * tn, int incr ) { tn->count += incr;

} // Удаление всех узлов дерева в обходе с отложенной // выборкой. Используется в ~B_tree().

void cleanup (T_node *tn) { if(!tn) return;

if(tn->left) { cleanup(tn->left);

tn->left = 0;

} if(tn->right != 0 ) { cleanup(tn->right);

tn->right = 0;

} delete tn;

} // рекурсивно печатает значения в поддереве с корнем tn // (обход дерева с предварительной выборкой) void print_pre(const T_node * tn) const { if(!tn) return;

cout << tn->val << " ";

if(tn->left) print_pre(tn->left);

if(tn->right) print_pre( tn->right );

} // рекурсивно печатает значения в поддереве с корнем tn // (обход дерева ) void print_in(const T_node * tn) const { if(!tn) return;

if(tn->left) print_in(tn->left);

cout << tn->val << " ";

if(tn->right) print_in(tn->right);

} // рекурсивно печатает значения в поддереве с корнем tn // (обход дерева с отложенной выборкой) void print_post(const T_node * tn) const { if(!tn) return;

if(tn->left) print_post(tn->left);

if(tn->right) print_post(tn->right);

cout << tn->val << " ";

} public:

B_tree() : zero_node(0) {root = 0;

} B_tree(const T root_val) : zero_node(0) { new_root(root_val);

} ~B_tree() { cleanup(root);

} // Добавляет к дереву через функцию insert_node() значение, если его // там еще нет. Возвращает true, если элемент добавлен, иначе false bool add(const T insert_value) { T_node *ret = insert_node(insert_value);

if(ret) return true;

else return false;

} // Find(T) возвращает true, если find_value найдено // в дереве, иначе false bool find(T find_value) { Tree_node *tn = find_node(find_value);

if(tn) return true;

else return false;

} // Print() производит обратную порядковую выборку // и печатает дерево "на боку" void print() const { cout << "\n=---------------------------\n"<< endl;

// Это вызов Binary_tree::Tree_node::print( ), // а не рекурсивный вызов Binary_tree::print( ).

root->print( );

} // последовательная печать дерева при обходе // с предварительной, порядковой и отложенной выборкой.

// Вызываются рекурсивные private-функции, принимающие // параметр Tree_node * void print_pre_order( ) const { print_pre(root);

cout << endl;

} void print_in_order( ) const { print_in(root);

cout << endl;

} void print_post_order( ) const { print_post(root);

cout << endl;

} };

Далее приведено содержимое файла Bt.cpp.

#include "bin_tree.h" B_tree my_bt( 7 );

// создание корня бинарного дерева // Заполнение дерева целыми значениями void populate( ) { my_bt.add( 5 );

my_bt.add( 5 );

my_bt.add( 9 );

my_bt.add( 6 );

my_bt.add( 5 );

my_bt.add( 9 );

my_bt.add( 4 );

my_bt.add( 11 );

my_bt.add( 8 );

my_bt.add( 19 );

my_bt.add( 2 );

my_bt.add( 10 );

my_bt.add( 19 );

} int main( ) { populate( );

my_bt.print ( );

cout << endl;

cout << "Pre-order: " ;

my_bt.print_pre_order ( );

cout << "Post-order: " ;

my_bt.print_post_order ( );

cout << "In-order: " ;

my_bt.print_in_order ( );

return 0;

} Результат работы программы:

@ 19(2) @ 11(1) @ 10(1) @ 9(2) @ 8(1) @ 7(1) @ 6(2) @ 5(1) @ 4(1) @ 2(1) @ Pre-order : 7 5 4 2 6 9 8 11 10 Post-order : 2 4 6 5 8 10 19 11 9 In-order : 2 4 5 6 7 8 9 10 11 B_tree содержит вложенный закрытый класс T_node (структуру) для представления внутреннего описания элемента (узла) бинарного дерева. Струк тура его скрыта от пользователя. Поле val содержит значение, хранимое в узле, left и right – указатели на левый и правый потомки данного узла.

В классе B_tree два открытых конструктора. Конструктор по умолчанию создает пустое бинарное дерево B_tree, а конструктор В_tree(const T) дерево с одним узлом. Деструктор ~B_tree() удаляет каждый T_node, производя обход бинарного дерева с отложенной выборкой. Отложенная выборка гарантирует, что никакой узел не будет удален, пока не удалены его потомки.

Для объектов класса B_tree с целью упрощения не определены (а только объявлены закрытыми) конструктор копирования и операция присваивания.

Это позволяет компилятору сообщить об ошибке при попытке выполнить эти операции. Если эти операции потребуется использовать, то их необходимо сде лать открытыми и определить.

Функция find_node() возвращает ссылку на указатель T_node. Для того чтобы функция могла сослаться на нулевой указатель, вводится поле zero_node.

Рекурсивные функции print_pre_order(), print_in_order() и print_post_order() печатают элементы дерева в линейной последовательности в соответствии со стандартными схемами обхода двоичного дерева. Функция print_pre_order() печатает значение узла до того, как будет напечатан любой из его потомков. Функция print_post_order(), наоборот, печатает значение узла только после того, как будут напечатаны все его потомки. И, наконец, функция print_in_order() выводит на печать элементы бинарного дерева в порядке воз растания.

Литература 1. Дейтел Х., Дейтел П. Как программировать на С++: Пер. с англ. – М.:

ЗАО «Издательство БИНОМ», 2001. – 1152 с.: ил.

2. Шилд Г. Программирование на Borland C++ для профессионалов. –Мн.:

ООО «Попурри», 1998. – 800 с.

3. Скляров В.А. Язык С++ и объектно-ориентированное программи рование. Мн.: Выш. шк., 1997. – 478 с.: ил.

4. Ирэ П. Объектно-ориентированное программирование с использова нием С++: Пер. с англ. – Киев: НИПФ «ДиаСофт Лтд», 1995. – 480 с.

Содержание Введение................................................................................................................. Объектно-ориентированное программирование................................................ Абстрактные типы данных............................................................................... Базовые принципы объектно-ориентированного программирования......... Основные достоинства языка С++................................................................... Особенности языка С++.................................................................................... Ключевые слова............................................................................................. Константы и переменные.............................................................................. Операции........................................................................................................ Типы данных.................................................................................................. Передача аргументов функции по умолчанию........................................... Простейший ввод и вывод................................................................................ Объект cout.................................................................................................... Манипуляторы hex и oct............................................................................... Объект cin.................................................................................................... Операторы для динамического выделения и освобождения памяти (new и delete).................................................................................................... Базовые конструкции объектно-ориентированных......................................... программ............................................................................................................... Объекты............................................................................................................ Понятие класса................................................................................................. Конструктор explicit........................................................................................ Встроенные функции (спецификатор inline)................................................ Организация внешнего доступа к локальным компонентам класса (спецификатор friend)..................................................................................... Вложенные классы.......................................................................................... Static-члены (данные) класса.......................................................................... Указатель this................................................................................................... Компоненты-функции static и const............................................................... Ссылки.............................................................................................................. Параметры ссылки....................................................................................... Независимые ссылки................................................................................... Наследование (производные классы)............................................................ Конструкторы и деструкторы..................................................................... Виртуальные функции.................................................................................... Абстрактные классы........................................................................................ Множественное наследование........................................................................ Виртуальное наследование......................................................................... Перегрузка функций........................................................................................ Перегрузка операторов.................................................................................... Перегрузка бинарного оператора............................................................... Перегрузка унарного оператора................................................................. Дружественная функция operator............................................................... Особенности перегрузки операции присваивания................................... Перегрузка оператора [].............................................................................. Перегрузка оператора ().............................................................................. Перегрузка оператора ->............................................................................. Перегрузка операторов new и delete......................................................... Преобразование типа....................................................................................... Явные преобразования типов..................................................................... Преобразования типов, определенных в программе................................ Шаблоны........................................................................................................... Параметризированные классы.................................................................... Передача в шаблон класса дополнительных параметров........................ Шаблоны функций..................................................................................... Совместное использование шаблонов и наследования......................... Некоторые примеры использования шаблона класса............................ Задание свойств класса................................................................................. Пространства имен........................................................................................ Ключевое слово using как директива....................................................... Ключевое слово using как объявление.................................................... Псевдоним пространства имен................................................................. Организация ввода-вывода........................................................................... Состояние потока....................................................................................... Строковые потоки...................................................................................... Организация работы с файлами................................................................... Организация файла последовательного доступа.................................... Создание файла произвольного доступа................................................. Основные функции классов ios, istream, ostream........................................ Исключения в С++............................................................................................. Основы обработки исключительных ситуаций.......................................... Перенаправление исключительных ситуаций............................................ Исключительная ситуация, генерируемая оператором new...................... Генерация исключений в конструкторах.................................................... Задание собственной функции завершения................................................ Спецификации исключительных ситуаций................................................ Задание собственного неожиданного обработчика................................... Иерархия исключений стандартной библиотеки....................................... Стандартная библиотека шаблонов (STL)..................................................... Общее понятие о контейнере....................................................................... Общее понятие об итераторе........................................................................ Категории итераторов................................................................................... Основные итераторы..................................................................................... Вспомогательные итераторы........................................................................ Операции с итераторами............................................................................... Контейнерные классы................................................................................... Контейнеры последовательностей............................................................... Контейнер последовательностей vector................................................ Контейнер последовательностей list..................................................... Контейнер последовательностей deque................................................ Ассоциативные контейнеры......................................................................... Ассоциативный контейнер multiset..................................................... Ассоциативный контейнер set.............................................................. Ассоциативный контейнер multimap................................................... Ассоциативный контейнер map........................................................... Адаптеры контейнеров.................................................................................. Адаптеры stack......................................................................................... Адаптеры queue........................................................................................ Адаптеры priority_queue.......................................................................... Пассивные и активные итераторы............................................................... Алгоритмы...................................................................................................... Алгоритмы сортировки sort, partial_sort, sort_heap.............................. Алгоритмы поиска find, find_if, find_end, binary_search........................ Алгоритмы fill, fill_n, generate и generate_n...................................... Алгоритмы equal, mismatch и lexicographical_compare...................... Математические алгоритмы..................................................................... Алгоритмы работы с множествами......................................................... Алгоритмы swap, iter_swap и swap_ranges.............................................. Алгоритмы copy, copy_backward, merge, unique и reverse..................... Примеры реализации контейнерных классов............................................. Связанные списки...................................................................................... Реализация односвязного списка......................................................... Реализация двусвязного списка........................................................... Реализация двоичного дерева................................................................... Литература...................................................................................................... Св. план 2003, резерв Учебное издание Луцик Юрий Александрович, Ковальчук Анна Михайловна, Лукьянова Ирина Викторовна ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ НА ЯЗЫКЕ С++ Учебное пособие по курсу «Объектно-ориентированное программирование» для студентов специальности «Вычислительные машины, системы и сети» всех форм обучения Редактор Т.А. Лейко Корректор Е.Н. Батурчик _ Подписано в печать 12.12.2003. Формат 60х84 1/16. Бумага офсетная.

Печать ризографическая. Гарнитура «Таймс». Усл. печ. л. 11,97.

Уч.- изд. л. 12,0. Тираж 200 экз. Заказ 414.

_ Издатель и полиграфическое исполнение:

Учреждение образования «Белорусский государственный университет информатики и радиоэлектроники».

Лицензия ЛП № 156 от 30.12. 2002.

Лицензия ЛВ № 509 от 03.08. 2001.

Pages:     | 1 | 2 ||



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.