Синтаксис перехвата исключений

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

try {

Фрагмент, который может инициировать исключения

catch (Exception Type t) {

Восстановление после исключения типа Exception Type

catch (...) {

Восстановление после исключений всех остальных типов

Каждый обработчик, за исключением (опять нечаянный каламбур) обработчика с многоточием, соответствует одному конкретному типу ошибок. Если из фрагмента, называемого try-блоком, инициируется исключение, компилятор просматривает список обработчиков в порядке их перечисления и ищет обработчик, подходящий по типу запущенного исключения. Многоточие соответствует исключениям любого типа; если такой обработчик присутствует, он должен находиться последним в списке.

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

Выполнение программы после исключения

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

catch(int exception) {

Сделать что-то, а затем

throw( He1p! ); Инициируется исключение типа char*

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

Если исключение не перехвачено

Если для исключения не найдется ни одного обработчика, по умолчанию вызывается глобальная функция terminate() . Как вы думаете, что она делает? По умолчанию terminate() в конечном счете вызывает библиотечную функцию abort() , и дело кончается аварийным завершением всей программы. Вы можете вмешаться и установить собственную функцию завершения с помощью библиотечной функции set terminate(). Соответствующий фрагмент файла except.h выглядит так:

typedef void (*terminate function)();

termination function set terminate(terminate function t func);

В строке typedef... объявляется интерфейс к вашей функции завершения. Функция set terminate() устанавливает функцию завершения, которую вместо функции abort() вызывает функция terminate() . Функция set terminate() возвращает текущую функцию завершения, которую позднее можно восстановить повторным вызовом set terminate() .

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

Вложенная обработка исключений

Да, вложение блоков try/catch разрешается, хотя пользоваться этой возможностью следует как можно реже, если только вы хотите сохранить дружеские отношения с персоналом сопровождения вашей программы.

try {

try { try {

Ненадежный фрагмент

catch(...) { }

catch(...) {

catch(...) {

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

Внешние исключения не перехватываются!

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

Конструкторы и деструкторы

Одно из принципиальных достоинств стандартной схемы обработки исключений - раскрутка стека (unwinding the stack). При запуске исключения автоматически вызываются деструкторы всех стековых объектов между throw и catch.

void fn() throw(int) { Foo aFoo; Что-то не так! throw(bad news);

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

Bar b;

fn(); Вызывает исключение

catch(int exception) {

Перед тем, как мы попадем сюда, будет вызван деструктор b

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

Уничтожаемые объекты

Гарантируется вызов деструкторов всех стековых объектов, сконструированных с начала выполнения try-блока, но и только. Например, допустим, что к моменту возникновения исключения был сконструирован массив. Деструкторы вызываются лишь для тех объектов массива, которые были сконструированы до возникновения исключения.

Динамические объекты (то есть созданные посредством оператора new) - совсем другое дело. Вам придется самостоятельно следить за ними. Если в куче размещаются объекты, которые должны уничтожаться в результате исключения, обычно для них создается оболочка в виде вспомогательного стекового объекта.

class TempFoo { private:

Foo* f; public:

TempFoo(Foo* aFoo) : f(aFoo) {} ~TempFoo() { delete f; }

try {

TempFoo tf(new Foo); и т.д.

catch(...) {

Foo уничтожается деструктором tf

Исключения во время конструирования

Рассмотрим следующий процесс конструирования: class Foo {...} class Bar : public Foo { private: A a;

B b;

public:

Bar();

Bar::Bar()

X x;

throw(bad news); Y y;