* законченный учебник и руководство по языку
| Вид материала | Закон |
- Евгений Гришковец, 4370.48kb.
- Домашнее задание по русскому языку на 2 сессию Учебник, 136.34kb.
- Домашнее задание по русскому языку на 4 сессию Учебник, 95.55kb.
- Домашнее задание по русскому языку на 4 сессию Учебник, 85.3kb.
- Домашнее задание по русскому языку на 2 сессию Учебник, 96.88kb.
- Домашнее задание по русскому языку на III сессию Учебник, 71.08kb.
- Тематическое планирование по английскому языку предмет Класс, 508.61kb.
- Московский государственный институт международных отношений (университет) мид, 1816.26kb.
- Авторы: В. П. Канакина, В. Г. Горецкий, 503.03kb.
- Домашняя работа по русскому языку за 5 класс к учебнику "Русский язык: учебник для, 9.85kb.
class X { /* ... */ };
void f(int a, int b)
{
X < a > b>; // Как это понимать: X b и потом
// недопустимая лексема, или X< (a>b) >; ?
}
Этот пример синтаксически ошибочен, поскольку первая угловая скобка
> завершает параметр шаблона. В маловероятном случае, когда вам
понадобится параметр шаблона, являющийся выражением "больше чем",
используйте скобки: X< (a>b)>.
8.7 Шаблоны типа и производные классы
Мы уже видели, что сочетание производных классов (наследование) и
шаблонов типа может быть мощным средством. Шаблон типа выражает
общность между всеми типами, которые используются как его параметры,
а базовый класс выражает общность между всеми представлениями
(объектами) и называется интерфейсом. Здесь возможны некоторые
простые недоразумения, которых надо избегать.
Два созданных по одному шаблону типа будут различны и между ними
невозможно отношение наследования кроме единственного случая, когда
у этих типов идентичны параметры шаблона. Например:
template
class Vector { /* ... */ }
Vector
Vector
Vector
Здесь v1 и v3 одного типа, а v2 имеет совершенно другой тип. Из того
факта, что short неявно преобразуется в int, не следует, что есть
неявное преобразование Vector
v2 = v3; // несоответствие типов
Но этого и следовало ожидать, поскольку нет встроенного преобразования
int[] в short[].
Аналогичный пример:
class circle: public shape { /* ... */ };
Vector
Vector
Vector
Здесь v4 и v6 одного типа, а v5 имеет совершенно другой тип. Из того
факта, что существует неявное преобразование circle в shape и
circle* в shape*, не следует, что есть неявные преобразования
Vector
Vector
v5 = v6; // несоответствие типов
Дело в том, что в общем случае структура (представление) класса,
созданного по шаблону типа, такова, что для нее не предполагаются
отношения наследования. Так, созданный по шаблону класс может
содержать объект типа, заданного в шаблоне как параметр, а не просто
указатель на него. Кроме того, допущение подобных преобразований
приводит к нарушению контроля типов:
void f(Vector
{
Vector
(*ps)[2] = new square; // круглую ножку суем в квадратное
// отверстие (память выделена для
// square, а используется для circle
}
На примерах шаблонов Islist, Tlink, Slist, Splist, Islist_iter,
Slist_iter и SortableVector мы видели, что шаблоны типа дают
удобное средство для создания целых семейств классов. Без шаблонов
создание таких семейств только с помощью производных классов
может быть утомительным занятием, а значит, ведущим к ошибкам.
С другой стороны, если отказаться от производных классов и использовать
только шаблоны, то появляется множество копий функций-членов шаблонных
классов, множество копий описательной части шаблонных классов и во
множестве повторяются функции, использующие шаблоны типа.
8.7.1 Задание реализации с помощью параметров шаблона
В контейнерных классах часто приходится выделять память. Иногда
бывает необходимо (или просто удобно) дать пользователю возможность
выбирать из нескольких вариантов выделения памяти, а также позволить
ему задавать свой вариант. Это можно сделать несколькими способами.
Один из способов состоит в том, что определяется шаблон типа для
создания нового класса, в интерфейс которого входит описание
соответствующего контейнера и класса, производящего выделение памяти
по способу, описанному в $$6.7.2:
template
: public Container
// ...
void some_function()
{
// ...
T* p = new(A::operator new(sizeof(T))) T;
// ...
}
// ...
};
Шаблон типа здесь необходим, поскольку мы создаем контейнерный класс.
Наследование от Container
можно было использовать как контейнерный класс. Шаблон типа с
параметром A позволит нам использовать различные функции размещения:
class Shared : public Arena { /* ... */ };
class Fast_allocator { /* ... */ };
Controlled_container
ptbl;
Controlled_container
Controlled_container
payroll;
Это универсальный способ предоставлять производным классам
содержательную информацию о реализации. Его положительными качествами
являются систематичность и возможность использовать функции-подстановки.
Для этого способа характерны необычно длинные имена. Впрочем, как
обычно, typedef позволяет задать синонимы для слишком длинных имен
типов:
typedef
Controlled_container
pp_record;
pp_record payroll;
Обычно шаблон типа для создания такого класса как pp_record используют
только в том случае, когда добавляемая информация по реализации
достаточно существенна, чтобы не вносить ее в производный класс ручным
программированием. Примером такого шаблона может быть общий
(возможно, для некоторых библиотек стандартный) шаблонный класс
Comparator ($$8.4.2), а также нетривиальные (возможно, стандартные
для некоторых библиотек) классы Allocator (классы для выделения памяти).
Отметим, что построение производных классов в таких примерах
идет по "основному проспекту", который определяет интерфейс с
пользователем (в нашем примере это Container). Но есть и "боковые
улицы", задающие детали реализации.
8.8 Ассоциативный массив
Из всех универсальных невстроенных типов самым полезным, по всей
видимости, является ассоциативный массив. Его часто называют
таблицей (map), а иногда словарем, и он хранит пары значений.
Имея одно из значений, называемое ключом, можно получить доступ
к другому, называемому просто значением. Ассоциативный массив
можно представлять как массив, в котором индекс не обязан быть
целым:
template
// ...
public:
V& operator[](const K&); // найти V, соответствующее K
// и вернуть ссылку на него
// ...
};
Здесь ключ типа K обозначает значение типа V. Предполагается, что
ключи можно сравнивать с помощью операций == и <, так что массив
можно хранить в упорядоченном виде. Отметим, что класс Map
отличается от типа assoc из $$7.8 тем, что для него нужна операция
"меньше чем", а не функция хэширования.
Приведем простую программу подсчета слов, в которой используются
шаблон Map и тип String:
#include
#include
#include "Map.h"
int main()
{
Map
String word;
while (cin >> word) count[word]++;
for (Mapiter
cout << p.value() << '\t' << p.key() << '\n';
return 0;
}
Мы используем тип String для того, чтобы не беспокоиться о выделении
памяти и переполнении ее, о чем приходится помнить, используя тип
char*. Итератор Mapiter нужен для выбора по порядку всех значений
массива. Итерация в Mapiter задается как имитация работы
с указателями. Если входной поток имеет вид
It was new. It was singular. It was simple. It must succeed.
программа выдаст
4 It
1 must
1 new.
1 simple.
1 singular.
1 succeed.
3 was.
Конечно, определить ассоциативный массив можно многими способами, а,
имея определение Map и связанного с ним класса итератора, мы можем
предложить много способов для их реализации. Здесь выбран
тривиальный способ реализации. Используется линейный поиск, который
не подходит для больших массивов. Естественно, рассчитанная на
коммерческое применение реализация будет создаваться, исходя из
требований быстрого поиска и компактности представления
(см. упражнение 4 из $$8.9).
Мы используем список с двойной связью Link:
template
template
template
friend class Map
friend class Mapiter
private:
const K key;
V value;
Link* pre;
Link* suc;
Link(const K& k, const V& v) : key(k), value(v) { }
~Link() { delete suc; } // рекурсивное удаление всех
// объектов в списке
};
Каждый объект Link содержит пару (ключ, значение). Классы описаны
в Link как друзья, и это гарантирует, что объекты Link можно
создавать, работать с ними и уничтожать только с помощью
соответствующих классов итератора и Map. Обратите внимание на
предварительные описания шаблонных классов Map и Mapiter.
Шаблон Map можно определить так:
template
friend class Mapiter
Link
Link
V def_val;
K def_key;
int sz;
void find(const K&);
void init() { sz = 0; head = 0; current = 0; }
public:
Map() { init(); }
Map(const K& k, const V& d)
: def_key(k), def_val(d) { init(); }
~Map() { delete head; } // рекурсивное удаление
// всех объектов в списке
Map(const Map&);
Map& operator= (const Map&);
V& operator[] (const K&);
int size() const { return sz; }
void clear() { delete head; init(); }
void remove(const K& k);
// функции для итерации
Mapiter
{
(void) operator[](k); // сделать k текущим элементом
return Mapiter
}
Mapiter
Mapiter
};
Элементы хранятся в упорядоченном списке с дойной связью. Для
простоты ничего не делается для ускорения поиска
(см. упражнение 4 из $$8.9). Ключевой здесь является функция
operator[]():
template
V& Map
{
if (head == 0) {
current = head = new Link
current->pre = current->suc = 0;
return current->value;
}
Link
for (;;) {
if (p->key == k) { // найдено
current = p;
return current->value;
}
if (k < p->key) { // вставить перед p (в начало)
current = new Link
current->pre = p->pre;
current->suc = p;
if (p == head) // текущий элемент становится начальным
head = current;
else
p->pre->suc = current;
p->pre = current;
return current->value;
}
Link
if (s == 0) { // вставить после p (в конец)
current = new Link
current->pre = p;
current->suc = 0;
p->suc = current;
return current->value;
}
p = s;
}
}
Операция индексации возвращает ссылку на значение, которое
соответствует заданному как параметр ключу. Если такое значение
не найдено, возвращается новый элемент со стандартным значением.
Это позволяет использовать операцию индексации в левой части
присваивания. Стандартные значения для ключей и значений
устанавливаются конструкторами Map. В операции индексации определяется
значение current, используемое итераторами.
Реализация остальных функций-членов оставлена в качестве
упражнения:
template
void Map
{
// см. упражнение 2 из $$8.10
}
template
Map
{
// копирование таблицы Map и всех ее элементов
}
template
Map& Map
{
// копирование таблицы Map и всех ее элементов
}
Теперь нам осталось только определить итерацию. В классе Map
есть функции-члены first(), last() и element(const K&), которые
возвращают итератор, установленный соответственно на первый, последний
или задаваемый ключом-параметром элемент. Сделать это можно, поскольку
элементы хранятся в упорядоченном по ключам виде.
Итератор Mapiter для Map определяется так:
template
friend class Map
Map
Link
Mapiter(Map
{ m = mm; p = pp; }
public:
Mapiter() { m = 0; p = 0; }
Mapiter(Map
operator void*() { return p; }
const K& key();
V& value();
Mapiter& operator--(); // префиксная
void operator--(int); // постфиксная
Mapiter& operator++(); // префиксная
void operator++(int); // постфиксная
};
После позиционирования итератора функции key() и value() из Mapiter
выдают ключ и значение того элемента, на который установлен
итератор.
template
{
if (p) return p->key; else return m->def_key;
}
template
{
if (p) return p->value; else return m->def_val;
}
По аналогии с указателями определены операции ++ и -- для продвижения
по элементам Map вперед и назад:
Mapiter
{
if (p) p = p->pre;
return *this;
}
void Mapiter
{
if (p) p = p->pre;
}
Mapiter
{
if (p) p = p->suc;
return *this;
}
void Mapiter
{
if (p) p = p->suc;
}
Постфиксные операции определены так, что они не возвращают никакого
значения. Дело в том, что затраты на создание и передачу нового
объекта Mapiter на каждом шаге итерации значительны, а польза от
него будет не велика.
Объект Mapiter можно инициализировать так, чтобы он был
установлен на начало Map:
template
{
m == &mm; p = m->head;
}
Операция преобразования operator void*() возвращает нуль, если
итератор не установлен на элемент Map, и ненулевое значение иначе.
Значит можно проверять итератор iter, например, так:
void f(Mapiter
{
// ...
if (iter) {
// установлен на элемент таблицы
}
else {
// не установлен на элемент таблицы
}
// ...
}
Аналогичный прием используется для контроля потоковых операций
ввода-вывода в $$10.3.2.
Если итератор не установлен на элемент таблицы, его функции
key() и value() возвращают ссылки на стандартные объекты.
Если после всех этих определений вы забыли их назначение, можно
привести еще одну небольшую программу, использующую таблицу Map.
Пусть входной поток является списком пар значений следующего вида:
hammer 2
nail 100
saw 3
saw 4
hammer 7
nail 1000
nail 250
Нужно отсортировать список так, чтобы значения, соответствующие одному
предмету, складывались, и напечатать получившийся список вместе с
итоговым значением:
hammer 9
nail 1350
saw 7
-------------------
total 1366
Вначале напишем функцию, которая читает входные строки и заносит
предметы с их количеством в таблицу. Ключом в этой таблице является
первое слово строки:
template
void readlines(Map
{
K word;
while (cin >> word) {
V val = 0;
if (cin >> val)
key[word] +=val;
else
return;
}
}
Теперь можно написать простую программу, вызывающую функцию
readlines() и печатающую получившуюся таблицу:
main()
{
Map
readlines(tbl);
int total = 0;
for (Mapiter
int val = p.value();
total +=val;
cout << p.key() << '\t' << val << '\n';
}
cout << "--------------------\n";
cout << "total\t" << total << '\n';
}
8.9 Упражнения
1. (*2) Определите семейство списков с двойной связью, которые
будут двойниками списков с одной связью, определенных в $$8.3.
2. (*3) Определите шаблон типа String, параметром которого является
тип символа. Покажите как его можно использовать не только для
обычных символов, но и для гипотетического класса lchar, который
представляет символы не из английского алфавита или расширенный
набор символов. Нужно постараться так определить String, чтобы
пользователь не заметил ухудшения характеристик программы по
памяти и времени или в удобстве по сравнению с обычным строковым
классом.
3. (*1.5) Определите класс Record (запись) с двумя членами-данными:
count (количество) и price (цена). Упорядочите вектор из таких
записей по каждому из членов. При этом нельзя изменять функцию
сортировки и шаблон Vector.
4. (*2) Завершите определения шаблонного класса Map, написав
недостающие функции-члены.
5. (*2) Задайте другую реализацию Map из $$8.8, используя списочный
класс с двойной связью.
6. (*2.5) Задайте другую реализацию Map из $$8.8, используя
сбалансированное дерево. Такие деревья описаны в $$6.2.3 книги
Д. Кнут "Искусство программирования для ЭВМ" т.1, "Мир", 1978 [K].
7. (*2) Сравните качество двух реализаций Map. В первой используется
класс Link со своей собственной функцией размещения, а во второй
- без нее.
8. (*3) Сравните производительность программы подсчета слов из
$$8.8 и такой же программы, не использующей класса Map. Операции
ввода-вывода должны одинаково использоваться в обеих программах.
Сравните несколько таких программ, использующих разные варианты
класса Map, в том числе и класс из вашей библиотеки, если он там
есть.
9. (*2.5) С помощью класса Map реализуйте топологическую сортировку.
Она описана в [K] т.1, стр. 323-332. (см. упражнение 6).
10. (*2) Модифицируйте программу из $$8.8 так, чтобы она работала
правильно для длинных имен и для имен, содержащих пробелы
(например, "thumb back").
11. (*2) Определите шаблон типа для чтения различных видов строк,
например, таких (предмет, количество, цена).
12. (*2) Определите класс Sort из $$8.4.5, использующий сортировку
по методу Шелла. Покажите как можно задать метод сортировки
с помощью параметра шаблона. Алгоритм сортировки описан в [K]
т.3, $$5.2.1 (см. упражнение 6).
13. (*1) Измените определения Map и Mapiter так, чтобы постфиксные
операции ++ и -- возвращали объект Mapiter.
14. (*1.5) Используйте шаблоны типа в стиле модульного
программирования, как это было показано в $$8.4.5 и напишите
функцию сортировки, рассчитанную сразу на Vector
* ГЛАВА 9
Я прервал вас, поэтому не прерывайте меня.
- Уинстон Черчилл
В этой главе описан механизм обработки особых ситуаций и некоторые,
основывающиеся на нем, способы обработки ошибок. Механизм состоит
в запуске особой ситуации, которую должен перехватить специальный
обработчик. Описываются правила перехвата особых ситуаций и
правила реакции на неперехваченные и неожиданные особые ситуации.
Целые группы особых ситуаций можно определить как производные
классы. Описывается способ, использующий деструкторы и обработку
особых ситуаций, который обеспечивает надежное и скрытое от
пользователя управление ресурсами.
9.1 Обработка ошибок
Создатель библиотеки способен обнаружить динамические ошибки, но не
представляет какой в общем случае должна быть реакция на них.
Пользователь библиотеки способен написать реакцию на такие ошибки,
но не в силах их обнаружить. Если бы он мог, то сам разобрался бы
с ошибками в своей программе, и их не пришлось бы выявлять
в библиотечных функциях. Для решения этой проблемы в язык введено
понятие особой ситуации Ь.
Ь Только недавно комитетом по стандартизации С++ особые ситуации были
включены в стандарт языка, но на время написания этой книги они еще
не вошли в большинство реализаций.
Суть этого понятия в том, что функция, которая обнаружила ошибку и не
может справиться с нею, запускает особую ситуацию, рассчитывая, что
устранить проблему можно в той функции, которая прямо или опосредованно
вызывала первую. Если функция рассчитана на обработку ошибок некоторого
вида, она может указать это явно, как готовность перехватить данную
особую ситуацию.
Рассмотрим в качестве примера как для класса Vector можно
представлять и обрабатывать особые ситуации, вызванные выходом за
границу массива:
class Vector {
int* p;
int sz;
public:
class Range { }; // класс для особой ситуации
int& operator[](int i);
// ...
};
Предполагается, что объекты класса Range будут использоваться как
особые ситуации, и запускать их можно так:
int& Vector::operator[](int i)
{
if (0<=i && i
throw Range();
}
Если в функции предусмотрена реакция на ошибку недопустимого значения
индекса, то ту часть функции, в которой эти ошибки будут перехватываться,
надо поместить в оператор try. В нем должен быть и обработчик особой
ситуации:
void f(Vector& v)
{
// ...
try {
do_something(v); // содержательная часть, работающая с v
}
catch (Vector::Range) {
// обработчик особой ситуации Vector::Range
// если do_something() завершится неудачно,
// нужно как-то среагировать на это
// сюда мы попадем только в том случае, когда
// вызов do_something() приведет к вызову Vector::operator[]()
// из-за недопустимого значения индекса
}
// ...
}
Обработчиком особой ситуации называется конструкция
catch ( /* ... */ ) {
// ...
}
Ее можно использовать только сразу после блока, начинающегося служебным
словом try, или сразу после другого обработчика особой ситуации. Служебным
является и слово catch. После него идет в скобках описание, которое
используется аналогично описанию формальных параметров функции, а именно,
в нем задается тип объектов, на которые рассчитан обработчик, и,
возможно, имена параметров (см. $$9.3). Если в do_something() или в
любой вызванной из нее функции произойдет ошибка индекса (на любом
объекте Vector), то обработчик перехватит особую ситуацию и будет
выполняться часть, обрабатывающая ошибку. Например, определения следующих
функций приведут к запуску обработчика в f():
void do_something()
{
// ...
crash(v);
// ...
}
void crash(Vector& v)
{
v[v.size()+10]; // искусственно вызываем ошибку индекса
}
Процесс запуска и перехвата особой ситуации предполагает просмотр
цепочки вызовов от точки запуска особой ситуации до функции, в которой
она перехватывается. При этом восстанавливается состояние стека,
соответствующее функции, перехватившей ошибку, и при проходе по всей
цепочке вызовов для локальных объектов функций из этой цепочки вызываются
деструкторы. Подробно это описано в $$9.4.
Если при просмотре всей цепочки вызовов, начиная с запустившей
особую ситуацию функции, не обнаружится подходящий обработчик, то
программа завершается. Подробно это описано в $$9.7.
Если обработчик перехватил особую ситуацию, то она будет обрабатываться
и другие, рассчитанные на эту ситуацию, обработчики не будут
рассматриваться. Иными словами, активирован будет только тот обработчик,
который находится в самой последней вызывавшейся функции, содержащей
соответствующие обработчики. В нашем примере функция f() перехватит
Vector::Range, поэтому эту особую ситуацию нельзя перехватить ни в
какой вызывающей f() функции:
int ff(Vector& v)
{
try {
f(v); // в f() будет перехвачена Vector::Range
}
catch (Vector::Range) { // значит сюда мы никогда не попадем
// ...
}
}
9.1.1 Особые ситуации и традиционная обработка ошибок
Наш способ обработки ошибок по многим параметрам выгодно отличается от
более традиционных способов. Перечислим, что может сделать операция
индексации Vector::operator[]() при обнаружении недопустимого значения
индекса:
[1] завершить программу;
[2] возвратить значение, трактуемое как "ошибка";
[3] возвратить нормальное значение и оставить программу в
неопределенном состоянии;
[4] вызвать функцию, заданную для реакции на такую ошибку.
Вариант [1] ("завершить программу") реализуется по умолчанию в том
случае, когда особая ситуация не была перехвачена. Для большинства
ошибок можно и нужно обеспечить лучшую реакцию.
Вариант [2] ("возвратить значение "ошибка"") можно реализовать
не всегда, поскольку не всегда удается определить значение "ошибка".
Так, в нашем примере любое целое является допустимым значением для
результата операции индексации. Если можно выделить такое особое
значение, то часто этот вариант все равно оказывается неудобным,
поскольку проверять на это значение приходится при каждом вызове. Так
можно легко удвоить размер программы. Поэтому для обнаружения всех
ошибок этот вариант редко используется последовательно.
Вариант [3] ("оставить программу в неопределенном состоянии")
имеет тот недостаток, что вызывавшая функция может не заметить
ненормального состояния программы. Например, во многих функциях
стандартной библиотеки С для сигнализации об ошибке устанавливается
соответствующее значение глобальной переменной errno. Однако,
в программах пользователя обычно нет достаточно последовательного
контроля errno, и в результате возникают наведенные ошибки,
вызванные тем, что стандартные функции возвращают не то значение.
Кроме того, если в программе есть параллельные вычисления,
использование одной глобальной переменной для сигнализации о разных
ошибках неизбежно приведет к катастрофе.
Обработка особых ситуаций не предназначалась для тех случаев,
на которые рассчитан вариант [4] ( "вызвать функцию реакции на
ошибку"). Отметим, однако, что если особые ситуации не предусмотрены,
то вместо функции реакции на ошибку можно как раз использовать
только один из трех перечисленных вариантов. Обсуждение функций
реакций и особых ситуацией будет продолжено в $$9.4.3.
Механизм особых ситуаций успешно заменяет традиционные
способы обработки ошибок в тех случаях, когда последние являются
неполным, некрасивым или чреватым ошибками решением. Этот механизм
позволяет явно отделить часть программы, в которой обрабатываются
ошибки, от остальной ее части, тем самым программа становится более
понятной и с ней проще работать различным сервисным программам.
Свойственный этому механизму регулярный способ обработки ошибок
упрощает взаимодействие между раздельно написанными частями
программы.
В этом способе обработки ошибок есть для программирующих на С
новый момент: стандартная реакция на ошибку (особенно на ошибку
в библиотечной функции) состоит в завершении программы. Традиционной
была реакция продолжать программу в надежде, что она как-то
завершится сама. Поэтому способ, базирующийся на особых ситуациях,
делает программу более "хрупкой" в том смысле, что требуется
больше усилий и внимания для ее нормального выполнения. Но это все-таки
лучше, чем получать неверные результаты на более поздней стадии
развития программы (или получать их еще позже, когда программу
сочтут завершенной и передадут ничего не подозревающему пользователю).
Если завершение программы является неприемлемой реакцией, можно
смоделировать традиционную реакцию с помощью перехвата всех особых
ситуаций или всех особых ситуаций, принадлежащих специальному
классу ($$9.3.2).
Механизм особых ситуаций можно рассматривать как динамический
аналог механизма контроля типов и проверки неоднозначности
на стадии трансляции. При таком подходе более важной становится
стадия проектирования программы, и требуется большая поддержка
процесса выполнения программы, чем для программ на С. Однако,
в результате получится более предсказуемая программа, ее будет проще
встроить в программную систему, она будет понятнее другим программистам и
с ней проще будет работать различным сервисным программам. Можно
сказать, что механизм особых ситуаций поддерживает,
подобно другим средствам С++, "хороший" стиль программирования,
который в таких языках, как С, можно применять только не в полном
объеме и на неформальном уровне.
Все же надо сознавать, что обработка ошибок остается трудной
задачей, и, хотя механизм особых ситуаций более строгий,
чем традиционные способы, он все равно недостаточно структурирован
по сравнению с конструкциями, допускающими только локальную передачу
управления.
9.1.2 Другие точки зрения на особые ситуации
"Особая ситуация" - одно из тех понятий, которые имеют разный смысл
для разных людей. В С++ механизм особых ситуаций предназначен для
обработки ошибок. В частности, он предназначен для обработки ошибок
в программах, состоящих из независимо создаваемых компонентов.
Этот механизм рассчитан на особые ситуации, возникающие только при
последовательном выполнении программы (например, контроль границ
массива). Асинхронные особые ситуации такие, например, как прерывания
от клавиатуры, нельзя непосредственно обрабатывать с помощью этого
механизма. В различных системах существуют другие механизмы,
например, сигналы, но они здесь не рассматриваются, поскольку зависят
от конкретной системы.
Механизм особых ситуаций является конструкцией с нелокальной
передачей управления и его можно рассматривать как вариант оператора
return. Поэтому особые ситуации можно использовать для целей, никак
не связанных с обработкой ошибок ($$9.5). Все-таки основным
назначением механизма особых ситуаций и темой этой главы будет
обработка ошибок и создание устойчивых к ошибкам программ.
9.2 Различение особых ситуаций
Естественно, в программе возможны несколько различных динамических
ошибок. Эти ошибки можно сопоставить с особыми ситуациями, имеющими
различные имена. Так, в классе Vector обычно приходится выявлять
и сообщать об ошибках двух видов: ошибки диапазона и ошибки,
вызванные неподходящим для конструктора параметром:
class Vector {
int* p;
int sz;
public:
enum { max = 32000 };
class Range { }; // особая ситуация индекса
class Size { }; // особая ситуация "неверный размер"
Vector(int sz);
int& operator[](int i);
// ...
};
Как было сказано, операция индексации запускает особую ситуацию
Range, если ей задан выходящий из диапазона значений индекс.
Конструктор запускает особую ситуацию Size, если ему задан
недопустимый размер вектора:
Vector::Vector(int sz)
{
if (sz<0 || max
// ...
}
Пользователь класса Vector может различить эти две особые ситуации,
если в проверяемом блоке (т.е. в блоке оператора try) укажет
обработчики для обеих ситуаций:
void f()
{
try {
use_vectors();
}
catch (Vector::Range) {
// ...
}
catch (Vector::Size) {
// ...
}
}
В зависимости от особой ситуации будет выполняться соответствующий
обработчик. Если управление дойдет до конца операторов обработчика,
следующим будет выполняться оператор, который идет после списка
обработчиков:
void f()
{
try {
use_vectors();
}
catch (Vector::Range) {
// исправить индекс и
// попробовать опять:
f();
}
catch (Vector::Size) {
cerr << "Ошибка в конструкторе Vector::Size";
exit(99);
}
// сюда мы попадем, если вообще не было особых ситуаций
// или после обработки особой ситуации Range
}
Список обработчиков напоминает переключатель, но здесь в теле
обработчика операторы break не нужны. Синтаксис списка обработчиков
отличен от синтаксиса вариантов case переключателя частично по
этой причине, частично потому, чтобы показать, что каждый
обработчик определяет свою область видимости (см. $$9.8).
Не обязательно все особые ситуации перехватывать в одной функции:
void f1()
{
try {
f2(v);
}
catch (Vector::Size) {
// ...
}
}
void f2(Vector& v)
{
try {
use_vectors();
}
catch (Vector::Range) {
// ...
}
}
Здесь f2() перехватит особую ситуацию Range, возникающую в
use_vectors(), а особая ситуация Size будет оставлена для f1().
С точки зрения языка особая ситуация считается обработанной сразу
при входе в тело ее обработчика. Поэтому все особые ситуации,
запускаемые при выполнении этого обработчика, должны обрабатываться
в функциях, вызвавших ту функцию, которая содержит проверяемый блок.
Значит в следующем примере не возникнет бесконечного цикла:
try {
// ...
}
catch (input_overflow) {
// ...
throw input_overflow();
}
Здесь input_overflow (переполнение при вводе) - имя глобального класса.
Обработчики особых ситуаций могут быть вложенными:
try {
// ...
}
catch (xxii) {
try {
// сложная реакция
}
catch (xxii) {
// ошибка в процессе сложной реакции
}
}
Однако, такая вложенность редко бывает нужна в обычных программах,
и чаще всего она является свидетельством плохого стиля.
9.3 Имена особых ситуаций
Особая ситуация перехватывается благодаря своему типу. Однако,
запускается ведь не тип, а объект. Если нам нужно передать некоторую
информацию из точки запуска в обработчик, то для этого ее следует
поместить в запускаемый объект. Например, допустим нужно знать
значение индекса, выходящее за границы диапазона:
class Vector {
// ...
public:
class Range {
public:
int index;
Range(int i) : index(i) { }
};
// ...
int& operator[](int i)
// ...
};
int Vector::operator[](int i)
{
if (o<=i && i
throw Range(i);
}
Чтобы исследовать недопустимое значение индекса, в обработчике
нужно дать имя объекту, представляющему особую ситуацию:
void f(Vector& v)
{
// ...
try {
do_something(v);
}
catch (Vector::Range r ) {
cerr << "недопустимый индекс" << r.index << '\n';
// ...
}
// ...
}
Конструкция в скобках после служебного слова catch является по сути
описанием и она аналогична описанию формального параметра функции.
В ней указывается каким может быть тип параметра (т.е. особой
ситуации) и может задаваться имя для фактической, т.е. запущенной,
особой ситуации. Вспомним, что в шаблонах типов у нас был выбор
для именования особых ситуаций. В каждом созданном по шаблону классе
был свой класс особой ситуации:
template
// ...
class Exhausted { }
// ...
T* get();
};
void f(Allocator