Механизм обработки особых ситуаций

9.4.3 Исчерпание ресурса

Есть одна из вечных проблем программирования: что делать, если не удалось удовлетворить запрос на ресурс? Например, в предыдущем примере мы спокойно открывали с помощью fopen() файлы и запрашивали с помощью операции new блок свободной памяти, не задумываясь при этом, что такого файла может не быть, а свободная память может исчерпаться. Для решения такого рода проблем у программистов есть два способа:

• Повторный запрос: пользователь должен изменить свой запрос и повторить его.
• Завершение: запросить дополнительные ресурсы от системы, если их нет, запустить особую ситуацию.

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

В С++ первый способ поддержан механизмом вызова функций, а второй - механизмом особых ситуаций. Оба способа можно продемонстрировать на примере реализации и использования операции new:

#include <stdlib.h>

extern void* _last_allocation;

extern void* operator new(size_t size)
{
  void* p;

  while ( (p=malloc(size))==0 ) {
     if (_new_handler)
        (*_new_handler)();  // обратимся за помощью
     else
        return 0;
  }
  return _last_allocation=p;
}

Если операция new() не может найти свободной памяти, она обращается к управляющей функции _new_handler(). Если в _new_handler() можно выделить достаточный объем памяти, все нормально. Если нет, из управляющей функции нельзя возвратиться в операцию new, т.к. возникнет бесконечный цикл. Поэтому управляющая функция может запустить особую ситуацию и предоставить исправлять положение программе, обратившейся к new:

void my_new_handler()
{
  try_find_some_memory();   // попытаемся найти
            // свободную память
  if (found_some()) return; // если она найдена, все в порядке
  throw Memory_exhausted(); // иначе запускаем особую
                            // ситуацию "Исчерпание_памяти"
}

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

try {
    // ...
}
catch (Memory_exhausted) {
    // ...
}

В функции operator new() использовался указатель на управляющую функцию _new_handler, который настраивается стандартной функцией set_new_handler(). Если нужно настроиться на собственную управляющую функцию, надо обратиться так

set_new_handler(&my_new_handler);

Перехватить ситуацию Memory_exhausted можно следующим образом:

void (*oldnh)() = set_new_handler(&my_new_handler);

try {
   // ...
}
catch (Memory_exhausted) {
   // ...
}
catch (...) {
   set_new_handler(oldnh);  // восстановить указатель на
            // управляющую функцию
   throw();      // повторный запуск особой ситуации
}

set_new_handler(oldnh); // восстановить указатель на
                        // управляющую функцию

Можно поступить еще лучше, если к управляющей функции применить описанный в 9.4 метод "запроса ресурсов путем инициализации" и убрать обработчик catch (...).

В решении, использующим my_new_handler(), от точки обнаружения ошибки до функции, в которой она обрабатывается, не передается никакой информации. Если нужно передать какие-то данные, то пользователь может включить свою управляющую функцию в класс. Тогда в функции, обнаружившей ошибку, нужные данные можно поместить в объект этого класса. Подобный способ, использующий объекты-функции, применялся в 10.4.2 для реализации манипуляторов. Способ, в котором используется указатель на функцию или объект-функция для того, чтобы из управляющей функции, обслуживающей некоторый ресурс, произвести "обратный вызов" функции, запросившей этот ресурс, обычно называется просто обратным вызовом (callback).

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

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

9.4.4 Особые ситуации и конструкторы

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

1. Возвратить объект в ненормальном состоянии в расчете, что пользователь проверит его состояние.
2. Установить значение нелокальной переменной, которое сигнализирует, что создать объект не удалось.

Особые ситуации позволяют тот факт, что создать объект не удалось, передать из конструктора вовне:

Vector::Vector(int size)
{
   if (sz<0 || max<sz) throw Size();
   // ...
}

В функции, создающей вектора, можно перехватить ошибки, вызванные недопустимым размером ( Size() ) и попытаться на них отреагировать:

Vector* f(int i)
{
  Vector* p;
  try {
    p = new Vector v(i);
  }
  catch (Vector::Size) {
    // реакция на недопустимый размер вектора
  }
  // ...
  return p;
}

Управляющая созданием вектора функция способна правильно отреагировать на ошибку. В самом обработчике особой ситуации можно применить какой-нибудь из стандартных способов диагностики и восстановления после ошибки. При каждом перехвате особой ситуации в управляющей функции может быть свой взгляд на причину ошибки. Если с каждой особой ситуацией передаются описывающие ее данные, то объем данных, которые нужно анализировать для каждой ошибки, растет. Основная задача обработки ошибок в том, чтобы обеспечить надежный и удобный способ передачи данных от исходной точки обнаружения ошибки до того места, где после нее возможно осмысленное восстановление.

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