Страница:
с помощью особой ситуации. Последнее соображение подсказывает, что
в самом общем шаблоне типа для очереди придется для обозначения пустой
очереди использовать особую ситуацию, а работающая с очередью функция
будет такой:
void f(Queue<X>& q)
{
try {
for (;;) { // ``бесконечный цикл''
// прерываемый особой ситуацией
X m = q.get();
// ...
}
}
catch (Queue<X>::Empty) {
return;
}
}
Если приведенный цикл выполняется тысячи раз, то он, по всей
видимости, будет более эффективным, чем обычный цикл с проверкой
условия пустоты очереди. Если же он выполняется только несколько
раз, то обычный цикл почти наверняка эффективней.
В очереди общего вида особая ситуация используется как способ
возврата из функции get(). Использование особых ситуаций как способа
возврата может быть элегантным способом завершения функций поиска.
Особенно это подходит для рекурсивных функций поиска в дереве. Однако,
применяя особые ситуации для таких целей, легко перейти грань разумного
и получить маловразумительную программу. Все-таки всюду, где это
действительно оправдано, надо придерживаться той точки зрения, что
обработка особой ситуации есть обработка ошибки. Обработка ошибок по
самой своей природе занятие сложное, поэтому ценность имеют любые
методы, которые дают ясное представление ошибок в языке и способ
их обработки.
Запуск или перехват особой ситуации отражается на взаимоотношениях
функций. Поэтому имеет смысл задавать в описании функции множество
особых ситуаций, которые она может запустить:
void f(int a) throw (x2, x3, x4);
В этом описании указано, что f() может запустить особые ситуации
x2, x3 и x4, а также ситуации всех производных от них типов, но
больше никакие ситуации она не запускает. Если функция перечисляет свои
особые ситуации, то она дает определенную гарантию всякой вызывающей ее
функции, а именно, если попытается запустить иную особую ситуацию, то
это приведет к вызову функции unexpected().
Стандартное предназначение unexpected() состоит в вызове функции
terminate(), которая, в свою очередь, обычно вызывает abort().
Подробности даны в $$9.7.
По сути определение
void f() throw (x2, x3, x4)
{
// какие-то операторы
}
эквивалентно такому определению
void f()
{
try {
// какие-то операторы
}
catch (x2) { // повторный запуск
throw;
}
catch (x3) { // повторный запуск
throw;
}
catch (x4) { // повторный запуск
throw;
}
catch (...) {
unexpected();
}
}
Преимущество явного задания особых ситуаций функции в ее описании
перед эквивалентным способом, когда происходит проверка на
особые ситуации в теле функции, не только в более краткой записи.
Главное здесь в том, что описание функции входит в ее интерфейс,
который видим для всех вызывающих функций. С другой стороны,
определение функции может и не быть универсально доступным.
Даже если у вас есть исходные тексты всех библиотечных функций,
обычно желание изучать их возникает не часто.
Если в описании функции не указаны ее особые ситуации, считается,
что она может запустить любую особую ситуацию.
int f(); // может запустить любую особую ситуацию
Если функция не будет запускать никаких особых ситуаций, ее можно
описать, явно указав пустой список:
int g() throw (); // не запускает никаких особых ситуаций
Казалось было бы логично, чтобы по умолчанию функция не запускала
никаких особых ситуаций. Но тогда пришлось бы описывать свои особые
ситуации практически для каждой функции Это, как правило,
требовало бы ее перетрансляции, а кроме того препятствовало бы общению
с функциями, написанными на других языках. В результате программист
стал бы стремиться отключить механизм особых ситуаций и писал бы
излишние операторы, чтобы обойти их. Пользователь считал бы такие
программы надежными, поскольку мог не заметить подмены, но это было
бы совершенно неоправдано.
Если к описанию особых ситуаций относиться не достаточно серьезно, то
результатом может быть вызов unexpected(), что нежелательно во всех
случая, кроме отладки. Избежать вызова unexpected() можно, если хорошо
организовать структуру особых ситуации и описание интерфейса. С
другой стороны, вызов unexpected() можно перехватить и сделать его
безвредным.
Если компонент Y хорошо разработан, все его особые ситуации
могут быть только производными одного класса, скажем Yerr. Поэтому,
если есть описание
class someYerr : public Yerr { /* ... */ };
то функция, описанная как
void f() throw (Xerr, Yerr, IOerr);
будет передавать любую особую ситуацию типа Yerr вызывающей функции.
В частности, обработка особой ситуации типа someYerr в f() сведется к
передаче ее вызывающей f() функции.
Бывает случаи, когда окончание программы при появлении
неожиданной особой ситуации является слишком строгим решением.
Допустим функция g() написана для несетевого режима в распределенной
системе. Естественно, в g() ничего неизвестно об особых ситуациях,
связанных с сетью, поэтому при появлении любой из них вызывается
unexpected(). Значит для использования g() в распределенной системе
нужно предоставить обработчик сетевых особых ситуаций или переписать
g(). Если допустить, что переписать g() невозможно или нежелательно,
проблему можно решить, переопределив действие функции unexpected().
Для этого служит функция set_unexpected(). Вначале мы определим
класс, который позволит нам применить для функций unexpected()
метод "запроса ресурсов путем инициализации" :
typedef void(*PFV)();
PFV set_unexpected(PFV);
class STC { // класс для сохранения и восстановления
PFV old; // функций unexpected()
public:
STC(PFV f) { old = set_unexpected(f); }
~STC() { set_unexpected(old); }
};
Теперь мы определим функцию, которая должна в нашем примере заменить
unexpected():
void rethrow() { throw; } // перезапуск всех сетевых
// особых ситуаций
Наконец, можно дать вариант функции g(), предназначенный для работы
в сетевом режиме:
void networked_g()
{
STC xx(&rethrow); // теперь unexpected() вызывает rethrow()
g();
}
В предыдущем разделе было показано, что unexpected() потенциально
вызывается из обработчика catch (...). Значит в нашем случае
обязательно произойдет повторный запуск особой ситуации. Повторный
запуск, когда особая ситуация не запускалась, приводит к вызову
terminate(). Поскольку обработчик catch (...) находится вне той
области видимости, в которой была запущена сетевая особая ситуация,
бесконечный цикл возникнуть не может.
Есть еще одно, довольно опасное, решение, когда на неожиданную
особую ситуацию просто "закрывают глаза":
void muddle_on() { cerr << "не замечаем особой ситуации\n"; }
// ...
STC xx(&muddle_on); // теперь действие unexpected() сводится
// просто к печати сообщения
Такое переопределение действия unexpected() позволяет нормально
вернуться из функции, обнаружившей неожиданную особую ситуацию.
Несмотря на свою очевидную опасность, это решение используется.
Например, можно "закрыть глаза" на особые ситуации в одной части
системы и отлаживать другие ее части. Такой подход может быть
полезен в процессе отладки и развития системы, перенесенной с языка
программирования без особых ситуаций. Все-таки, как правило лучше,
если ошибки проявляются как можно раньше.
Возможно другое решение, когда вызов unexpected() преобразуется
в запуск особой ситуации Fail (неудача):
void fail() { throw Fail; }
// ...
STC yy(&fail);
При таком решении вызывающая функция не должна подробно разбираться в
возможном результате вызываемой функции: эта функции завершится
либо успешно (т.е. возвратится нормально), либо неудачно (т.е.
запустит Fail). Очевидный недостаток этого решения в том, что
не учитывается дополнительная информация, которая может сопровождать
особую ситуацию. Впрочем, при необходимости ее можно учесть, если
передавать информацию вместе с Fail.
Если особая ситуация запущена и не перехвачена, то вызывается функция
terminate(). Она же вызывается, когда система поддержки особых
ситуаций обнаруживает, что структура стека нарушена, или когда
в процессе обработки особой ситуации при раскручивании стека вызывается
деструктор, и он пытается завершить свою работу, запустив особую
ситуацию.
Действие terminate() сводится к выполнению самой последней
функции, заданной как параметр для set_terminate():
typedef void (*PFV)();
PFV set_terminate(PFV);
Функция set_terminate() возвращает указатель на ту функцию, которая
была задана как параметр в предыдущем обращении к ней.
Необходимость такой функции как terminate() объясняется тем,
что иногда вместо механизма особых ситуаций требуются более
грубые приемы. Например, terminate() можно использовать для
прекращения процесса, а, возможно, и для повторного запуска системы.
Эта функция служит экстренным средством, которое применяется, когда
отказала стратегия обработки ошибок, рассчитанная на особые
ситуации, и самое время применить стратегию более низкого уровня.
Функция unexpected() используется в сходных, но не столь
серьезных случаях, а именно, когда функция запустила особую ситуацию,
не указанную в ее описании. Действие функции unexpected() сводится
к выполнению самой последней функции, заданной как параметр для
функции set_unexpected().
По умолчанию unexpected() вызывает terminate(), а та, в свою
очередь, вызывает функцию abort(). Предполагается, что такое соглашение
устроит большинство пользователей.
Предполагается, что функция terminate() не возвращается в
обратившеюся ней функцию.
Напомним, что вызов abort() свидетельствует о ненормальном
завершении программы. Для нормального выхода из программы
используется функция exit(). Она возвращает значение, которое
показывает окружающей системе насколько корректно закончилась программа.
Механизм особых ситуаций нужен для того, чтобы из одной части
программы можно было сообщить в другую о возникновении в первой
"особой ситуации". При этом предполагается, что части программы
написаны независимо друг от друга, и в той части, которая
обрабатывает особую ситуацию, возможна осмысленная реакция на
ошибку.
Как же должен быть устроен обработчик особой ситуации? Приведем
несколько вариантов:
int f(int arg)
{
try {
g(arg);
}
catch (x1) {
// исправить ошибку и повторить
g(arg);
}
catch (x2) {
// произвести вычисления и вернуть результат
return 2;
}
catch (x3) {
// передать ошибку
throw;
}
catch (x4) {
// вместо x4 запустить другую особую ситуацию
throw xxii;
}
catch (x5) {
// исправить ошибку и продолжить со следующего оператора
}
catch (...) {
// отказ от обработки ошибки
terminate();
}
// ...
}
Укажем, что в обработчике доступны переменные из области видимости,
содержащей проверяемый блок этого обработчика. Переменные,
описанные в других обработчиках или других проверяемых блоках,
конечно, недоступны:
void f()
{
int i1;
// ...
try {
int i2;
// ...
}
catch (x1) {
int i3;
// ...
}
catch (x4) {
i1 = 1; // нормально
i2 = 2; // ошибка: i2 здесь невидимо
i3 = 3; // ошибка: i3 здесь невидимо
}
}
Нужна общая стратегия для эффективного использования обработчиков в
программе. Все компоненты программы должны согласованно использовать
особые ситуации и иметь общую часть для обработки ошибок. Механизм
обработки особых ситуаций является нелокальным по своей сути,
поэтому так важно придерживаться общей стратегии. Это предполагает,
что стратегия обработки ошибок должна разрабатываться на самых
ранних стадиях проектах. Кроме того, эта стратегия должна
быть простой (по сравнению со сложностью всей программы) и ясной.
Последовательно проводить сложную стратегию в такой сложной
по своей природе области программирования, как восстановление после
ошибок, будет просто невозможно.
Прежде всего стоит сразу отказаться от того, что одно средство
или один прием можно применять для обработки всех ошибок. Это
только усложнит систему. Удачная система, обладающая устойчивостью
к ошибкам, должна строиться как многоуровневая. На каждом уровне
надо обрабатывать настолько много ошибок, насколько это возможно
без нарушения структуры системы, оставляя обработку других ошибок более
высоким уровням. Назначение terminate() поддержать такой подход,
предоставляя возможность экстренного выхода из такого положения,
когда нарушен сам механизм обработки особых ситуаций, или когда
он используется полностью, но особая ситуация оказалась
неперехваченной. Функция unexpected() предназначена для выхода из
такого положения, когда не сработало основанное на описании всех особых
ситуаций средство защиты. Это средство можно представлять как брандмауер,
т.е. стену, окружающую каждую функцию, и препятствующую
распространению ошибки. Попытка проводить в каждой функции полный
контроль, чтобы иметь гарантию, что функция либо успешно завершится,
либо закончится неудачно, но одним из определенных и корректных
способов, не может принести успех. Причины этого могут быть различными
для разных программ, но для больших программ можно назвать следующие:
[1] работа, которую нужно провести, чтобы гарантировать надежность
каждой функции, слишком велика, и поэтому ее не удастся
провести достаточно последовательно;
[2] появятся слишком большие дополнительные расходы памяти и времени,
которые будут недопустимы для нормальной работы системы
(будет тенденция неоднократно проверять на одну и ту же ошибку,
а значит постоянно будут проверяться переменные с правильными
значениями);
[3] таким ограничениям не будут подчиняться функции, написанные на
других языках;
[4] такое понятие надежности является чисто локальным и оно
настолько усложняет систему, что становится дополнительной
нагрузкой для ее общей надежности.
Однако, разбить программу на отдельные подсистемы, которые либо
успешно завершаются, либо заканчиваются неудачно, но одним из
определенных и корректных способов, вполне возможно, важно и даже
выгодно. Таким свойством должны обладать основные библиотеки,
подсистемы или ключевые функции. Описание особых ситуаций должно
входить в интерфейсы таких библиотек или подсистем.
Иногда приходится от одного стиля реакции на ошибку переходить
на другой. Например, можно после вызова стандартной функции С
проверять значение errno и, возможно, запускать особую ситуацию,
а можно, наоборот, перехватывать особую ситуацию и устанавливать
значение errno перед выходом из стандартной функции в С-программу:
void callC()
{
errno = 0;
cfunction();
if (errno) throw some_exception(errno);
}
void fromC()
{
try {
c_pl_pl_function();
}
catch (...) {
errno = E_CPLPLFCTBLEWIT;
}
}
При такой смене стилей важно быть последовательным, чтобы изменение
реакции на ошибку было полным.
Обработка ошибок должна быть, насколько это возможно, строго
иерархической системой. Если в функции обнаружена динамическая
ошибка, то не нужно обращаться за помощью для восстановления или
выделения ресурсов к вызывающей функции. При таких обращениях в
структуре системы возникают циклические зависимости, в результате
чего ее труднее понять, и возможно возникновение бесконечных
циклов в процессе обработки и восстановления после ошибки.
Чтобы часть программы, предназначенная для обработки ошибок
была более упорядоченной, стоит применять такие упрощающие дело
приемы, как "запрос ресурсов путем инициализации", и исходить из
таких упрощающих дело допущений, что "особые ситуации являются
ошибками".
1. (*2) Обобщите класс STC до шаблона типа, который позволяет
хранить и устанавливать функции разных типов.
2. (*3) Дополните класс CheckedPtrToT из $$7.10 до шаблона типа, в
котором особые ситуации сигнализируют о динамических ошибках.
3. (*3) Напишите функцию find для поиска в бинарном дереве узлов
по значению поля типа char*. Если найден узел с полем, имеющим
значение "hello", она должна возвращать указатель на него. Для
обозначения неудачного поиска используйте особую ситуацию.
4. (*1) Определите класс Int, совпадающий во всем со встроенным
типом int за исключением того, что вместо переполнения или
потери значимости в этом классе запускаются особые ситуации.
Подсказка: см. $$9.3.2.
5. (*2) Перенесите из стандартного интерфейса С в вашу операционную
систему основные операции с файлами: открытие, закрытие, чтение и
запись. Реализуйте их как функции на С++ с тем же назначением,
что и функций на С, но в случае ошибок запускайте особые
ситуации.
6. (*1) Напишите полное определение шаблона типа Vector с особыми
ситуациями Range и Size. Подсказка: см. $$9.3.
7. (*1) Напишите цикл для вычисления суммы элементов вектора,
определенного в упражнении 6, причем не проверяйте размер вектора.
Почему это плохое решение?
8. (*2.5) Допустим класс Exception используется как базовый для всех
классов, задающих особые ситуации. Каков должен быть его вид?
Какая от него могла быть польза? Какие неудобства может вызвать
требование обязательного использования этого класса?
9. (*2) Напишите класс или шаблон типа, который поможет реализовать
обратный вызов.
10. (*2) Напишите класс Lock (замок) для какой-нибудь системы,
допускающей параллельное выполнение.
11. (*1) Пусть определена функция
int main() { /* ... */ }
Измените ее так, чтобы в ней перехватывались все особые ситуации,
преобразовывались в сообщения об ошибке и вызов abort().
Подсказка: в функции fromC() из $$9.8 учтены не все случаи.
"Доступно только то, что видимо"
Б. Керниган
В языке С++ нет средств для ввода-вывода. Их и не нужно, поскольку
такие средства можно просто и элегантно создать на самом языке.
Описанная здесь библиотека потокового ввода-вывода реализует строгий
типовой и вместе с тем гибкий и эффективный способ символьного ввода и
вывода целых, вещественных чисел и символьных строк, а также является
базой для расширения, рассчитанного на работу с пользовательскими типами
данных. Пользовательский интерфейс библиотеки находится в файле
<iostream.h>. Эта глава посвящена самой потоковой библиотеке, некоторым
способам работы с ней и определенным приемам реализации библиотеки.
Широко известна трудность задачи проектирования и реализации
стандартных средств ввода-вывода для языков программирования.
Традиционно средства ввода-вывода были рассчитаны исключительно на
небольшое число встроенных типов данных. Однако, в нетривиальных
программах на С++ есть много пользовательских типов данных, поэтому
необходимо предоставить
возможность ввода-вывода значений таких типов. Очевидно, что средства
ввода-вывода должны быть простыми, удобными, надежными в использовании
и, что важнее всего, адекватными. Пока никто не нашел решения, которое
удовлетворило бы всех; поэтому необходимо дать возможность пользователю
создавать иные средства ввода-вывода, а также расширять стандартные
средства ввода-вывода в расчете на определенное применение.
Цель создания С++ была в том, чтобы пользователь мог определить новые
типы данных, работа с которыми была бы столь же удобна и эффективна как
и со встроенными типами. Таким образом, кажется разумным потребовать,
чтобы средства ввода-вывода для С++ программировались с использованием
возможностей С++, доступных каждому. Представленные здесь потоковые
средства ввода-вывода появились в результате попытки удовлетворить
этим требованиям.
Основная задача потоковых средств ввода-вывода - это процесс
преобразования объектов определенного типа в последовательность символов
и наоборот. Существуют и другие схемы ввода-вывода, но указанная является
основной, и если считать символ просто набором битов, игнорируя его
естественную связь с алфавитом, то многие схемы двоичного ввода-вывода
можно свести к ней. Поэтому программистская суть задачи сводится к
описанию связи между объектом определенного типа и бестиповой (что
существенно) строкой.
Последующие разделы описывают основные части потоковой библиотеки С++:
10.2 Вывод: То, что для прикладной программы представляется выводом,
на самом деле является преобразованием таких объектов как int,
char *, complex или Employee_record в последовательность символов.
Описываются средства для записи объектов встроенных и
пользовательских типов данных.
10.3 Ввод: Описаны функции для ввода символов, строк и значений
встроенных и пользовательских типов данных.
10.4 Форматирование: Часто существуют определенные требования к виду
вывода, например, int должно печататься десятичными цифрами,
указатели в шестнадцатеричной записи, а вещественные числа должны
быть с явно заданной точностью фиксированного размера.
Обсуждаются функции форматирования и определенные программистские
приемы их создания, в частности, манипуляторы.
10.5 Файлы и потоки: Каждая программа на С++ может использовать по
умолчанию три потока - стандартный вывод (cout), стандартный ввод
(cin) и стандартный поток ошибок (cerr). Чтобы работать с какими-
либо устройствами или файлами надо создать потоки и привязать их
к этим устройствам или файлам. Описывается механизм открытия и
закрытия файлов и связывания файлов с потоками.
10.6 Ввод-вывод для С: обсуждается функция printf из файла <stdio.h>
для С а также связь между библиотекой для С и <iostream.h> для
С++.
Укажем, что существует много независимых реализаций
потоковой библиотеки ввода-вывода и набор средств, описанных здесь, будет
только подмножеством средств, имеющихся в вашей библиотеке. Говорят,
что внутри любой большой программы есть маленькая программа, которая
стремится вырваться наружу. В этой главе предпринята попытка описать
как раз маленькую потоковую библиотеку ввода-вывода, которая позволит
оценить основные концепции потокового ввода-вывода и познакомить
с наиболее полезными средствами. Используя только средства,
описанные здесь, можно написать много программ; если возникнет
необходимость в более сложных средствах, обратитесь за деталями к вашему
руководству по С++. Заголовочный файл <iostream.h> определяет интерфейс
потоковой библиотеки. В ранних версиях потоковой библиотеки использовался
файл <stream.h>. Если существуют оба файла, <iostream.h> определяет полный
набор средств, а <stream.h> определяет подмножество, которое
совместимо с ранними, менее богатыми потоковыми библиотеками.
Естественно, для пользования потоковой библиотекой вовсе не нужно
знание техники ее реализации, тем более, что техника может быть
различной для различных реализаций. Однако, реализация ввода-вывода
является задачей, диктующей определенные условия, значит приемы, найденные
в процессе ее решения, можно применить и для других задач, а само это
решение достойно изучения.
Строгую типовую и единообразную работу как со встроенными, так и с
пользовательскими типами можно обеспечить, если использовать
единственное перегруженное имя функции для различных операций вывода.
Например:
put(cerr,"x = "); // cerr - выходной поток ошибок
put(cerr,x);
put(cerr,'\n');
Тип аргумента определяет какую функцию надо вызывать в каждом случае.
Такой подход применяется в нескольких языках, однако, это слишком
длинная запись. За счет перегрузки операции << , чтобы она означала
"вывести" ("put to"), можно получить более простую запись и разрешить
программисту выводить в одном операторе последовательность объектов,
например так:
cerr << "x = " << x << '\n';
Здесь cerr обозначает стандартный поток ошибок. Так, если х типа int
со значением 123, то приведенный оператор выдаст
x = 123
и еще символ конца строки в стандартный поток ошибок. Аналогично, если х
имеет пользовательский тип complex со значением (1,2.4), то указанный
оператор выдаст
x = (1,2.4)
в поток cerr. Такой подход легко использовать пока x такого типа, для
которого определена операция <<, а пользователь может просто
доопределить << для новых типов.
Мы использовали операцию вывода, чтобы избежать многословности,
неизбежной, если применять функцию вывода. Но почему именно символ << ?
Невозможно изобрести новую лексему (см. 7.2). Кандидатом для ввода и
вывода была операция присваивания, но большинство людей предпочитает,
чтобы операции ввода и вывода были различны. Более того, порядок
выполнения операции = неподходящий, так cout=a=b означает cout=(a=b).
Пробовали использовать операции < и >, но к ним так крепко привязано
понятие "меньше чем" и "больше чем", что операции ввода-вывода с ними
во всех практически случаях не поддавались прочтению.
Операции << и >> похоже не создают таких проблем. Они асиметричны,
что позволяет приписывать им смысл "в" и "из". Они не относятся к числу
наиболее часто используемых операций над встроенными типами, а
приоритет << достаточно низкий, чтобы писать арифметические выражения в
качестве операнда без скобок:
cout << "a*b+c=" << a*b+c << '\n';
Скобки нужны, если выражение содержит операции с более низким
приоритетом:
cout << "a^b|c=" << (a^b|c) << '\n';
Операцию сдвига влево можно использовать в операции вывода, но, конечно,
она должна быть в скобках:
cout << "a<<b=" << (a<<b) << '\n';
Для управления выводом встроенных типов определяется класс ostream
с операцией << (вывести):
class ostream : public virtual ios {
в самом общем шаблоне типа для очереди придется для обозначения пустой
очереди использовать особую ситуацию, а работающая с очередью функция
будет такой:
void f(Queue<X>& q)
{
try {
for (;;) { // ``бесконечный цикл''
// прерываемый особой ситуацией
X m = q.get();
// ...
}
}
catch (Queue<X>::Empty) {
return;
}
}
Если приведенный цикл выполняется тысячи раз, то он, по всей
видимости, будет более эффективным, чем обычный цикл с проверкой
условия пустоты очереди. Если же он выполняется только несколько
раз, то обычный цикл почти наверняка эффективней.
В очереди общего вида особая ситуация используется как способ
возврата из функции get(). Использование особых ситуаций как способа
возврата может быть элегантным способом завершения функций поиска.
Особенно это подходит для рекурсивных функций поиска в дереве. Однако,
применяя особые ситуации для таких целей, легко перейти грань разумного
и получить маловразумительную программу. Все-таки всюду, где это
действительно оправдано, надо придерживаться той точки зрения, что
обработка особой ситуации есть обработка ошибки. Обработка ошибок по
самой своей природе занятие сложное, поэтому ценность имеют любые
методы, которые дают ясное представление ошибок в языке и способ
их обработки.
Запуск или перехват особой ситуации отражается на взаимоотношениях
функций. Поэтому имеет смысл задавать в описании функции множество
особых ситуаций, которые она может запустить:
void f(int a) throw (x2, x3, x4);
В этом описании указано, что f() может запустить особые ситуации
x2, x3 и x4, а также ситуации всех производных от них типов, но
больше никакие ситуации она не запускает. Если функция перечисляет свои
особые ситуации, то она дает определенную гарантию всякой вызывающей ее
функции, а именно, если попытается запустить иную особую ситуацию, то
это приведет к вызову функции unexpected().
Стандартное предназначение unexpected() состоит в вызове функции
terminate(), которая, в свою очередь, обычно вызывает abort().
Подробности даны в $$9.7.
По сути определение
void f() throw (x2, x3, x4)
{
// какие-то операторы
}
эквивалентно такому определению
void f()
{
try {
// какие-то операторы
}
catch (x2) { // повторный запуск
throw;
}
catch (x3) { // повторный запуск
throw;
}
catch (x4) { // повторный запуск
throw;
}
catch (...) {
unexpected();
}
}
Преимущество явного задания особых ситуаций функции в ее описании
перед эквивалентным способом, когда происходит проверка на
особые ситуации в теле функции, не только в более краткой записи.
Главное здесь в том, что описание функции входит в ее интерфейс,
который видим для всех вызывающих функций. С другой стороны,
определение функции может и не быть универсально доступным.
Даже если у вас есть исходные тексты всех библиотечных функций,
обычно желание изучать их возникает не часто.
Если в описании функции не указаны ее особые ситуации, считается,
что она может запустить любую особую ситуацию.
int f(); // может запустить любую особую ситуацию
Если функция не будет запускать никаких особых ситуаций, ее можно
описать, явно указав пустой список:
int g() throw (); // не запускает никаких особых ситуаций
Казалось было бы логично, чтобы по умолчанию функция не запускала
никаких особых ситуаций. Но тогда пришлось бы описывать свои особые
ситуации практически для каждой функции Это, как правило,
требовало бы ее перетрансляции, а кроме того препятствовало бы общению
с функциями, написанными на других языках. В результате программист
стал бы стремиться отключить механизм особых ситуаций и писал бы
излишние операторы, чтобы обойти их. Пользователь считал бы такие
программы надежными, поскольку мог не заметить подмены, но это было
бы совершенно неоправдано.
Если к описанию особых ситуаций относиться не достаточно серьезно, то
результатом может быть вызов unexpected(), что нежелательно во всех
случая, кроме отладки. Избежать вызова unexpected() можно, если хорошо
организовать структуру особых ситуации и описание интерфейса. С
другой стороны, вызов unexpected() можно перехватить и сделать его
безвредным.
Если компонент Y хорошо разработан, все его особые ситуации
могут быть только производными одного класса, скажем Yerr. Поэтому,
если есть описание
class someYerr : public Yerr { /* ... */ };
то функция, описанная как
void f() throw (Xerr, Yerr, IOerr);
будет передавать любую особую ситуацию типа Yerr вызывающей функции.
В частности, обработка особой ситуации типа someYerr в f() сведется к
передаче ее вызывающей f() функции.
Бывает случаи, когда окончание программы при появлении
неожиданной особой ситуации является слишком строгим решением.
Допустим функция g() написана для несетевого режима в распределенной
системе. Естественно, в g() ничего неизвестно об особых ситуациях,
связанных с сетью, поэтому при появлении любой из них вызывается
unexpected(). Значит для использования g() в распределенной системе
нужно предоставить обработчик сетевых особых ситуаций или переписать
g(). Если допустить, что переписать g() невозможно или нежелательно,
проблему можно решить, переопределив действие функции unexpected().
Для этого служит функция set_unexpected(). Вначале мы определим
класс, который позволит нам применить для функций unexpected()
метод "запроса ресурсов путем инициализации" :
typedef void(*PFV)();
PFV set_unexpected(PFV);
class STC { // класс для сохранения и восстановления
PFV old; // функций unexpected()
public:
STC(PFV f) { old = set_unexpected(f); }
~STC() { set_unexpected(old); }
};
Теперь мы определим функцию, которая должна в нашем примере заменить
unexpected():
void rethrow() { throw; } // перезапуск всех сетевых
// особых ситуаций
Наконец, можно дать вариант функции g(), предназначенный для работы
в сетевом режиме:
void networked_g()
{
STC xx(&rethrow); // теперь unexpected() вызывает rethrow()
g();
}
В предыдущем разделе было показано, что unexpected() потенциально
вызывается из обработчика catch (...). Значит в нашем случае
обязательно произойдет повторный запуск особой ситуации. Повторный
запуск, когда особая ситуация не запускалась, приводит к вызову
terminate(). Поскольку обработчик catch (...) находится вне той
области видимости, в которой была запущена сетевая особая ситуация,
бесконечный цикл возникнуть не может.
Есть еще одно, довольно опасное, решение, когда на неожиданную
особую ситуацию просто "закрывают глаза":
void muddle_on() { cerr << "не замечаем особой ситуации\n"; }
// ...
STC xx(&muddle_on); // теперь действие unexpected() сводится
// просто к печати сообщения
Такое переопределение действия unexpected() позволяет нормально
вернуться из функции, обнаружившей неожиданную особую ситуацию.
Несмотря на свою очевидную опасность, это решение используется.
Например, можно "закрыть глаза" на особые ситуации в одной части
системы и отлаживать другие ее части. Такой подход может быть
полезен в процессе отладки и развития системы, перенесенной с языка
программирования без особых ситуаций. Все-таки, как правило лучше,
если ошибки проявляются как можно раньше.
Возможно другое решение, когда вызов unexpected() преобразуется
в запуск особой ситуации Fail (неудача):
void fail() { throw Fail; }
// ...
STC yy(&fail);
При таком решении вызывающая функция не должна подробно разбираться в
возможном результате вызываемой функции: эта функции завершится
либо успешно (т.е. возвратится нормально), либо неудачно (т.е.
запустит Fail). Очевидный недостаток этого решения в том, что
не учитывается дополнительная информация, которая может сопровождать
особую ситуацию. Впрочем, при необходимости ее можно учесть, если
передавать информацию вместе с Fail.
Если особая ситуация запущена и не перехвачена, то вызывается функция
terminate(). Она же вызывается, когда система поддержки особых
ситуаций обнаруживает, что структура стека нарушена, или когда
в процессе обработки особой ситуации при раскручивании стека вызывается
деструктор, и он пытается завершить свою работу, запустив особую
ситуацию.
Действие terminate() сводится к выполнению самой последней
функции, заданной как параметр для set_terminate():
typedef void (*PFV)();
PFV set_terminate(PFV);
Функция set_terminate() возвращает указатель на ту функцию, которая
была задана как параметр в предыдущем обращении к ней.
Необходимость такой функции как terminate() объясняется тем,
что иногда вместо механизма особых ситуаций требуются более
грубые приемы. Например, terminate() можно использовать для
прекращения процесса, а, возможно, и для повторного запуска системы.
Эта функция служит экстренным средством, которое применяется, когда
отказала стратегия обработки ошибок, рассчитанная на особые
ситуации, и самое время применить стратегию более низкого уровня.
Функция unexpected() используется в сходных, но не столь
серьезных случаях, а именно, когда функция запустила особую ситуацию,
не указанную в ее описании. Действие функции unexpected() сводится
к выполнению самой последней функции, заданной как параметр для
функции set_unexpected().
По умолчанию unexpected() вызывает terminate(), а та, в свою
очередь, вызывает функцию abort(). Предполагается, что такое соглашение
устроит большинство пользователей.
Предполагается, что функция terminate() не возвращается в
обратившеюся ней функцию.
Напомним, что вызов abort() свидетельствует о ненормальном
завершении программы. Для нормального выхода из программы
используется функция exit(). Она возвращает значение, которое
показывает окружающей системе насколько корректно закончилась программа.
Механизм особых ситуаций нужен для того, чтобы из одной части
программы можно было сообщить в другую о возникновении в первой
"особой ситуации". При этом предполагается, что части программы
написаны независимо друг от друга, и в той части, которая
обрабатывает особую ситуацию, возможна осмысленная реакция на
ошибку.
Как же должен быть устроен обработчик особой ситуации? Приведем
несколько вариантов:
int f(int arg)
{
try {
g(arg);
}
catch (x1) {
// исправить ошибку и повторить
g(arg);
}
catch (x2) {
// произвести вычисления и вернуть результат
return 2;
}
catch (x3) {
// передать ошибку
throw;
}
catch (x4) {
// вместо x4 запустить другую особую ситуацию
throw xxii;
}
catch (x5) {
// исправить ошибку и продолжить со следующего оператора
}
catch (...) {
// отказ от обработки ошибки
terminate();
}
// ...
}
Укажем, что в обработчике доступны переменные из области видимости,
содержащей проверяемый блок этого обработчика. Переменные,
описанные в других обработчиках или других проверяемых блоках,
конечно, недоступны:
void f()
{
int i1;
// ...
try {
int i2;
// ...
}
catch (x1) {
int i3;
// ...
}
catch (x4) {
i1 = 1; // нормально
i2 = 2; // ошибка: i2 здесь невидимо
i3 = 3; // ошибка: i3 здесь невидимо
}
}
Нужна общая стратегия для эффективного использования обработчиков в
программе. Все компоненты программы должны согласованно использовать
особые ситуации и иметь общую часть для обработки ошибок. Механизм
обработки особых ситуаций является нелокальным по своей сути,
поэтому так важно придерживаться общей стратегии. Это предполагает,
что стратегия обработки ошибок должна разрабатываться на самых
ранних стадиях проектах. Кроме того, эта стратегия должна
быть простой (по сравнению со сложностью всей программы) и ясной.
Последовательно проводить сложную стратегию в такой сложной
по своей природе области программирования, как восстановление после
ошибок, будет просто невозможно.
Прежде всего стоит сразу отказаться от того, что одно средство
или один прием можно применять для обработки всех ошибок. Это
только усложнит систему. Удачная система, обладающая устойчивостью
к ошибкам, должна строиться как многоуровневая. На каждом уровне
надо обрабатывать настолько много ошибок, насколько это возможно
без нарушения структуры системы, оставляя обработку других ошибок более
высоким уровням. Назначение terminate() поддержать такой подход,
предоставляя возможность экстренного выхода из такого положения,
когда нарушен сам механизм обработки особых ситуаций, или когда
он используется полностью, но особая ситуация оказалась
неперехваченной. Функция unexpected() предназначена для выхода из
такого положения, когда не сработало основанное на описании всех особых
ситуаций средство защиты. Это средство можно представлять как брандмауер,
т.е. стену, окружающую каждую функцию, и препятствующую
распространению ошибки. Попытка проводить в каждой функции полный
контроль, чтобы иметь гарантию, что функция либо успешно завершится,
либо закончится неудачно, но одним из определенных и корректных
способов, не может принести успех. Причины этого могут быть различными
для разных программ, но для больших программ можно назвать следующие:
[1] работа, которую нужно провести, чтобы гарантировать надежность
каждой функции, слишком велика, и поэтому ее не удастся
провести достаточно последовательно;
[2] появятся слишком большие дополнительные расходы памяти и времени,
которые будут недопустимы для нормальной работы системы
(будет тенденция неоднократно проверять на одну и ту же ошибку,
а значит постоянно будут проверяться переменные с правильными
значениями);
[3] таким ограничениям не будут подчиняться функции, написанные на
других языках;
[4] такое понятие надежности является чисто локальным и оно
настолько усложняет систему, что становится дополнительной
нагрузкой для ее общей надежности.
Однако, разбить программу на отдельные подсистемы, которые либо
успешно завершаются, либо заканчиваются неудачно, но одним из
определенных и корректных способов, вполне возможно, важно и даже
выгодно. Таким свойством должны обладать основные библиотеки,
подсистемы или ключевые функции. Описание особых ситуаций должно
входить в интерфейсы таких библиотек или подсистем.
Иногда приходится от одного стиля реакции на ошибку переходить
на другой. Например, можно после вызова стандартной функции С
проверять значение errno и, возможно, запускать особую ситуацию,
а можно, наоборот, перехватывать особую ситуацию и устанавливать
значение errno перед выходом из стандартной функции в С-программу:
void callC()
{
errno = 0;
cfunction();
if (errno) throw some_exception(errno);
}
void fromC()
{
try {
c_pl_pl_function();
}
catch (...) {
errno = E_CPLPLFCTBLEWIT;
}
}
При такой смене стилей важно быть последовательным, чтобы изменение
реакции на ошибку было полным.
Обработка ошибок должна быть, насколько это возможно, строго
иерархической системой. Если в функции обнаружена динамическая
ошибка, то не нужно обращаться за помощью для восстановления или
выделения ресурсов к вызывающей функции. При таких обращениях в
структуре системы возникают циклические зависимости, в результате
чего ее труднее понять, и возможно возникновение бесконечных
циклов в процессе обработки и восстановления после ошибки.
Чтобы часть программы, предназначенная для обработки ошибок
была более упорядоченной, стоит применять такие упрощающие дело
приемы, как "запрос ресурсов путем инициализации", и исходить из
таких упрощающих дело допущений, что "особые ситуации являются
ошибками".
1. (*2) Обобщите класс STC до шаблона типа, который позволяет
хранить и устанавливать функции разных типов.
2. (*3) Дополните класс CheckedPtrToT из $$7.10 до шаблона типа, в
котором особые ситуации сигнализируют о динамических ошибках.
3. (*3) Напишите функцию find для поиска в бинарном дереве узлов
по значению поля типа char*. Если найден узел с полем, имеющим
значение "hello", она должна возвращать указатель на него. Для
обозначения неудачного поиска используйте особую ситуацию.
4. (*1) Определите класс Int, совпадающий во всем со встроенным
типом int за исключением того, что вместо переполнения или
потери значимости в этом классе запускаются особые ситуации.
Подсказка: см. $$9.3.2.
5. (*2) Перенесите из стандартного интерфейса С в вашу операционную
систему основные операции с файлами: открытие, закрытие, чтение и
запись. Реализуйте их как функции на С++ с тем же назначением,
что и функций на С, но в случае ошибок запускайте особые
ситуации.
6. (*1) Напишите полное определение шаблона типа Vector с особыми
ситуациями Range и Size. Подсказка: см. $$9.3.
7. (*1) Напишите цикл для вычисления суммы элементов вектора,
определенного в упражнении 6, причем не проверяйте размер вектора.
Почему это плохое решение?
8. (*2.5) Допустим класс Exception используется как базовый для всех
классов, задающих особые ситуации. Каков должен быть его вид?
Какая от него могла быть польза? Какие неудобства может вызвать
требование обязательного использования этого класса?
9. (*2) Напишите класс или шаблон типа, который поможет реализовать
обратный вызов.
10. (*2) Напишите класс Lock (замок) для какой-нибудь системы,
допускающей параллельное выполнение.
11. (*1) Пусть определена функция
int main() { /* ... */ }
Измените ее так, чтобы в ней перехватывались все особые ситуации,
преобразовывались в сообщения об ошибке и вызов abort().
Подсказка: в функции fromC() из $$9.8 учтены не все случаи.
"Доступно только то, что видимо"
Б. Керниган
В языке С++ нет средств для ввода-вывода. Их и не нужно, поскольку
такие средства можно просто и элегантно создать на самом языке.
Описанная здесь библиотека потокового ввода-вывода реализует строгий
типовой и вместе с тем гибкий и эффективный способ символьного ввода и
вывода целых, вещественных чисел и символьных строк, а также является
базой для расширения, рассчитанного на работу с пользовательскими типами
данных. Пользовательский интерфейс библиотеки находится в файле
<iostream.h>. Эта глава посвящена самой потоковой библиотеке, некоторым
способам работы с ней и определенным приемам реализации библиотеки.
Широко известна трудность задачи проектирования и реализации
стандартных средств ввода-вывода для языков программирования.
Традиционно средства ввода-вывода были рассчитаны исключительно на
небольшое число встроенных типов данных. Однако, в нетривиальных
программах на С++ есть много пользовательских типов данных, поэтому
необходимо предоставить
возможность ввода-вывода значений таких типов. Очевидно, что средства
ввода-вывода должны быть простыми, удобными, надежными в использовании
и, что важнее всего, адекватными. Пока никто не нашел решения, которое
удовлетворило бы всех; поэтому необходимо дать возможность пользователю
создавать иные средства ввода-вывода, а также расширять стандартные
средства ввода-вывода в расчете на определенное применение.
Цель создания С++ была в том, чтобы пользователь мог определить новые
типы данных, работа с которыми была бы столь же удобна и эффективна как
и со встроенными типами. Таким образом, кажется разумным потребовать,
чтобы средства ввода-вывода для С++ программировались с использованием
возможностей С++, доступных каждому. Представленные здесь потоковые
средства ввода-вывода появились в результате попытки удовлетворить
этим требованиям.
Основная задача потоковых средств ввода-вывода - это процесс
преобразования объектов определенного типа в последовательность символов
и наоборот. Существуют и другие схемы ввода-вывода, но указанная является
основной, и если считать символ просто набором битов, игнорируя его
естественную связь с алфавитом, то многие схемы двоичного ввода-вывода
можно свести к ней. Поэтому программистская суть задачи сводится к
описанию связи между объектом определенного типа и бестиповой (что
существенно) строкой.
Последующие разделы описывают основные части потоковой библиотеки С++:
10.2 Вывод: То, что для прикладной программы представляется выводом,
на самом деле является преобразованием таких объектов как int,
char *, complex или Employee_record в последовательность символов.
Описываются средства для записи объектов встроенных и
пользовательских типов данных.
10.3 Ввод: Описаны функции для ввода символов, строк и значений
встроенных и пользовательских типов данных.
10.4 Форматирование: Часто существуют определенные требования к виду
вывода, например, int должно печататься десятичными цифрами,
указатели в шестнадцатеричной записи, а вещественные числа должны
быть с явно заданной точностью фиксированного размера.
Обсуждаются функции форматирования и определенные программистские
приемы их создания, в частности, манипуляторы.
10.5 Файлы и потоки: Каждая программа на С++ может использовать по
умолчанию три потока - стандартный вывод (cout), стандартный ввод
(cin) и стандартный поток ошибок (cerr). Чтобы работать с какими-
либо устройствами или файлами надо создать потоки и привязать их
к этим устройствам или файлам. Описывается механизм открытия и
закрытия файлов и связывания файлов с потоками.
10.6 Ввод-вывод для С: обсуждается функция printf из файла <stdio.h>
для С а также связь между библиотекой для С и <iostream.h> для
С++.
Укажем, что существует много независимых реализаций
потоковой библиотеки ввода-вывода и набор средств, описанных здесь, будет
только подмножеством средств, имеющихся в вашей библиотеке. Говорят,
что внутри любой большой программы есть маленькая программа, которая
стремится вырваться наружу. В этой главе предпринята попытка описать
как раз маленькую потоковую библиотеку ввода-вывода, которая позволит
оценить основные концепции потокового ввода-вывода и познакомить
с наиболее полезными средствами. Используя только средства,
описанные здесь, можно написать много программ; если возникнет
необходимость в более сложных средствах, обратитесь за деталями к вашему
руководству по С++. Заголовочный файл <iostream.h> определяет интерфейс
потоковой библиотеки. В ранних версиях потоковой библиотеки использовался
файл <stream.h>. Если существуют оба файла, <iostream.h> определяет полный
набор средств, а <stream.h> определяет подмножество, которое
совместимо с ранними, менее богатыми потоковыми библиотеками.
Естественно, для пользования потоковой библиотекой вовсе не нужно
знание техники ее реализации, тем более, что техника может быть
различной для различных реализаций. Однако, реализация ввода-вывода
является задачей, диктующей определенные условия, значит приемы, найденные
в процессе ее решения, можно применить и для других задач, а само это
решение достойно изучения.
Строгую типовую и единообразную работу как со встроенными, так и с
пользовательскими типами можно обеспечить, если использовать
единственное перегруженное имя функции для различных операций вывода.
Например:
put(cerr,"x = "); // cerr - выходной поток ошибок
put(cerr,x);
put(cerr,'\n');
Тип аргумента определяет какую функцию надо вызывать в каждом случае.
Такой подход применяется в нескольких языках, однако, это слишком
длинная запись. За счет перегрузки операции << , чтобы она означала
"вывести" ("put to"), можно получить более простую запись и разрешить
программисту выводить в одном операторе последовательность объектов,
например так:
cerr << "x = " << x << '\n';
Здесь cerr обозначает стандартный поток ошибок. Так, если х типа int
со значением 123, то приведенный оператор выдаст
x = 123
и еще символ конца строки в стандартный поток ошибок. Аналогично, если х
имеет пользовательский тип complex со значением (1,2.4), то указанный
оператор выдаст
x = (1,2.4)
в поток cerr. Такой подход легко использовать пока x такого типа, для
которого определена операция <<, а пользователь может просто
доопределить << для новых типов.
Мы использовали операцию вывода, чтобы избежать многословности,
неизбежной, если применять функцию вывода. Но почему именно символ << ?
Невозможно изобрести новую лексему (см. 7.2). Кандидатом для ввода и
вывода была операция присваивания, но большинство людей предпочитает,
чтобы операции ввода и вывода были различны. Более того, порядок
выполнения операции = неподходящий, так cout=a=b означает cout=(a=b).
Пробовали использовать операции < и >, но к ним так крепко привязано
понятие "меньше чем" и "больше чем", что операции ввода-вывода с ними
во всех практически случаях не поддавались прочтению.
Операции << и >> похоже не создают таких проблем. Они асиметричны,
что позволяет приписывать им смысл "в" и "из". Они не относятся к числу
наиболее часто используемых операций над встроенными типами, а
приоритет << достаточно низкий, чтобы писать арифметические выражения в
качестве операнда без скобок:
cout << "a*b+c=" << a*b+c << '\n';
Скобки нужны, если выражение содержит операции с более низким
приоритетом:
cout << "a^b|c=" << (a^b|c) << '\n';
Операцию сдвига влево можно использовать в операции вывода, но, конечно,
она должна быть в скобках:
cout << "a<<b=" << (a<<b) << '\n';
Для управления выводом встроенных типов определяется класс ostream
с операцией << (вывести):
class ostream : public virtual ios {