Язык программирования C++. Пятое издание - Стенли Липпман

void manip() {

try {

 // действия, приводящие к передаче исключения

} catch (...) {

 // действия по частичной обработке исключения

 throw;

}

Директива catch(...) применяется самостоятельно или в составе нескольких директив catch.

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

Упражнения раздела 18.1.2

Упражнение 18.4. Заглянув вперед в иерархию наследования на рис. 18.1, объясните, что неправильно в следующем блоке try. Исправьте его:

try {

 // использовать стандартную библиотеку С++

} catch(exception) {

 // ...

} catch(const runtime_error &re) {

 // ...

} catch(overflow_error eobj) { /* ... */ }

Упражнение 18.5. Измените следующую функцию main() так, чтобы обрабатывались исключения любых типов, представленных на рис. 18.1:

int main() {

 // использовать стандартную библиотеку С++

}

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

Упражнение 18.6. С учетом следующих типов исключений и директивы catch напишите выражение throw, создающее объект исключения, который может быть обработан каждым блоком catch:

(a) class exceptionType { };

    catch (exceptionType *pet) { }

(b) catch (...) { }

(c) typedef int EXCPTYPE;

    catch (EXCPTYPE) { }

18.1.3. Блок try функции и конструкторы

В принципе исключения могут произойти в любой точке программы. В частности, исключение может произойти в процессе инициализации в конструкторе. Инициализация в конструкторе выполняется прежде, чем его тело. Блок catch в теле конструктора не может обработать исключение, которое было передано при инициализации, поскольку блок try в теле конструктора еще не был задействован в момент передачи исключения.

Для обработки исключения, переданного при инициализации, конструктор следует оформить как блок try функции (function try block). Блок try функции позволяет ассоциировать группу директив catch с фазой инициализации конструктора (или фазой удаления деструктора), а равно с телом конструктора (или деструктора). В качестве примера заключим конструктор Blob() (см. раздел 16.1.2) в блок try функции:

template <typename Т>

Blob<T>::Blob(std::initializer list<T> il) try :

 data(std::make_shared<std::vector<T>>(il)) {

 /* пустое тело */

} catch(const std::bad_alloc &e) { handle_out_of_memory(e); }

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

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

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

Упражнения раздела 18.1.3

Упражнение 18.7. Определите классы Blob и BlobPtr из главы 16 так, чтобы для их конструкторов использовались блоки try функции.

18.1.4. Спецификатор исключения noexcept

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

По новому стандарту функция может пообещать не передавать исключения при помощи спецификации noexcept. Ключевое слово noexcept после списка параметров функции означает, что функция не будет передавать исключений:

void recoup (int) noexcept; // не будет передавать исключений

void alloc(int);            // может передавать исключения

Эти объявления заявляют, что функция recoup() не будет передавать исключений, а функция alloc() могла бы. Считается, что к функции recoup() применена спецификация запрета передачи исключения (nonthrowing specification).

Спецификатор noexcept должен присутствовать во всех объявлениях и в соответствующем определении функции или ни в одном из них. Спецификатор предшествует замыкающему типу (см. раздел 6.3.3). Спецификатор noexcept можно определить также в объявлении и определении указателя на функцию. Он неприменим к псевдониму типа или определению типа (typedef). В функции-члене спецификатор noexcept следует за квалификатором const или квалификатором ссылки, но предшествует квалификаторам final, override и = 0 у виртуальной функции.

Нарушение спецификации исключения

Важно понимать, что компилятор не проверяет спецификацию noexcept во время компиляции. Фактически компилятору не разрешено отклонять функцию со спецификатором noexcept просто потому, что она содержит оператор throw или вызывает функцию, которая может передавать исключение (однако хорошие компиляторы предупреждают о таких случаях):

// эта функция компилируется, хоть она и нарушает свою спецификацию

// исключения

void f() noexcept   // обещание не передавать исключений

{

 throw exception(); // нарушает спецификацию исключения

}

В результате вполне вероятно, что функция, обещавшая не передавать исключений, фактически передаст его. Если такая функция передаст исключение, для соблюдения обещания во время выполнения вызывается функция terminate(). Результат прокрутки стека непредсказуем. Таким образом, спецификатор noexcept следует использовать в двух случаях: если есть уверенность, что функция не будет передавать исключений, или если совершенно неизвестно, как справиться с ошибкой.

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

Во время компиляции компилятор может вообще не проверять спецификации исключения.

Совместимость с прежней версией. Спецификации исключения

У прежних версий языка С++ была более сложная схема спецификаций исключения, позволяющая определять типы исключений, которые могла бы передавать функция. Функция может определить ключевое слово throw, сопровождаемое заключенным в скобки списком типов, которые могла бы передать функция. Спецификатор throw располагается в том же месте, где и спецификатор noexcept в текущем языке.

Этот подход никогда широко не использовался и не рекомендован в текущем стандарте. Хотя один случай использования более сложной старой схемы распространен довольно широко. Функция, обозначенная как throw(), обещает не передавать никаких исключений:

void recoup(int) noexcept; // recoup() не передает ничего

void recoup(int) throw();  // эквивалентное объявление

Эти объявления функции recoup() эквивалентны. Оба указывают, что функция recoup() не будет передавать исключений.

Аргументы спецификации noexcept

Спецификатор noexcept получает необязательный аргумент, тип которого должен быть преобразуем в тип bool: если аргументом будет true, то функция не будет передавать исключений; если false — то может:

void recoup(int) noexcept(true); // не будет передавать исключений

void alloc(int) noexcept(false); // может передавать исключения