try…catch Пустой throw
Есть такое неофициальное понятие, как "пустой throw". Сейчас мы немного узнаем, что это такое.
Пустой throw, это когда нет обозначения вылавливаемого исключением типа, и есть только throw с завершающей точкой с запятой.
|
1 2 3 4 5 6 7 8 9 |
//C++ Листинг 0.0 Пустой throw int main(){ try{ } catch(...){ throw; // <-- Пустой throw } } |
У этой операции есть два назначения:
- Выход из цепочки работающих обработчиков детонируемых
throw
- Втаскивание хода работы в блок-обработчик исключительной ситуации
Поскольку на словах скорее всего трудно понять, что это должно значить, посмотрим на несколько примеров. Начнём со сброса. Иногда в некоторый try-catch вкладывают другой try-catch. И бывает, что нужно деактивизировать вложенный try-catch и продолжить работу во внешнем обработчике. Писать как-то сложнее, чем демонстрировать кодом, поэтому посмотрим на код для выяснения, о чём я пытаюсь рассказать:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
//С++ Листинг #1.1 Пустой throw как деактиватор, сбрасыватель обработки mingw #include <iostream> using std::cout; int main(){ try{ //try-catch_внешний (внутри отдельный, независимый блок try-catch) try{ //try-catch_внутренний throw 1; //возбуждаем исключительную ситуацию } catch(...){ //попадаем сюда cout << "catch_attachment\n"; //что-то делаем throw; //деактивируем этот (внутренний) обработчик } } catch(...){ //после деактивации попадаем во внешний обработчик cout << "catch_container\n"; //в котором продолжаем какую-то деятельность } } // |
- Cброс можно делать только в блоке обработки, т. е. только внутри catch, но не внутри try
- Сбрасываемая обработка должна быть обёрнута своим блоком try-catch, иначе сброс приводит к попытке выпрыгивания за пределы блоков try-catch, что приводит к ошибке неперехваченного исключения (см. листинг #1.2)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//C++ Листинг #1.2 Пустой throw без внешнего try-catch int main(){ //Внешний try-catch отсутствует try{ throw 1; } catch(...){ cout << "catch_attachment\n"; throw; //Попытка сброса приводит к ошибке "неперехваченное исключение" } } |
Кто-то из моих читателей может подумать, что "ага, всё понятно", но даже если и так, то не советую торопиться с выводами. Новичку запутаться очень несложно. Например, воспроизводя в коде программы текст обработки исключительной ситуации с попыткой сброса, новичок может написать что-то эдакое:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
//C++ Листинг #1.3 Возможная ошибка новичка, воспроизводящего деактивацию исключительной ситуации #include <iostream> using std::cout; int main(){ try{ throw 1; } catch(...){ try{ throw 1; } catch(...){ cout << "inner_catch, by throw2\n"; throw; //думал, что сбрасывает, а не тут-то было } cout << "out_catch, by throw 1\n"; } } |
В листинге #1.3 несколько раз возбуждаются исключительные ситуации в порядке цепной реакции, но в какой обработчик мы должны попасть? Компилятор ищет ближайший внешний (и при этом подходящий по типу), но такового нет, и происходит ошибка. Ближайший внешний от первого сработавшего throw. Можно сложить в матрёшку очень много исключений: когда после срабатывания одного throw будет детонировать ещё одно, а то детонировать своё, а то сдетонированное своё… Но сброс будет выводить нас в ближайший внешний catch от первого сдетонировавшего исключения:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
//C++ Листинг #1.4 Сброс выводит нас в ближайший внешний catch #include <iostream> #define A a using std::cout; class A{}; class B{}; class C{}; class D{}; int main(){ try{ //****************************************************// try{ throw A(); //Первое сработавшее throw } catch(...){ cout << "catch A\n"; try{ throw B(); //Второе } catch(...){ cout << "catch B\n"; try{ throw C(); //Третье } catch(...){ cout << "catch C\n"; throw; //Сброс } } cout << "test end_A\n"; //Здесь мы не окажемся, потому что это catch первого сработавшего throw, а мы выскакиваем из первого } //****************************************************// } catch(...){ //Ближайший внешний catch от "throw A()" cout << "catch main\n"; } } |
Теперь рассмотрим другой случай: втаскивание исключения в обработчик. Такое достигается путём использования пустого throw внутри обработчика, т. е. внутри блока catch, но чтобы втаскивание прошло удачно, нужно, чтобы некоторое исключение было активизировано, т. е. throw_тип должно "сдетонировать". Поскольку мои слова только всё усложнят, начнём с изучения примера:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
//С++ Листинг #2.1 try-catch, втаскивание в catch #include <iostream> using std::cout; int main(){ try{ //try-catch_блок как контейнер, хранящий в себе другой try-Блок throw 1; //внутри блок-контейнера активируется исключение (детонация) } catch(int){ //срабатывает блок обработки cout << "try_out_block\n"; try{ //Именно внутри блока обработки внутренний try-catch_блок throw; //И внутри такого внутреннего блока кидается пустой throw } catch(...){ //catch внутреннего try-catch_блока cout << "inner_catch"; //в него нас и втаскивает } } } |
Т. е. втаскивание, это когда можно не писать в бросаемое исключение тип, и всё равно затащит в блок обработчика, т. е. в catch. Но, ещё раз повторю, должно быть активизировано исключение, которое втащило ход работы в своий catch, а внутри такого блока catch можно втащить во внутренний catch, указав пустой throw в части try.
Будьте внимательными, для сброса пустой throw указываем обязательно в обработчике (в catch), а для втаскивания в блоке try. На самом деле запомнить это несложно: достаточно уметь немного логически мыслить: втащить можно, если мы ещё не в catch, а выйти, если мы уже в catch; и в одном и в другом случае должен быть внешний try-catch_блок, но в одном случае внутренний try-catch_блок в try-части внешнего try-catch_блока, а во втором в catch-части внешнего try-catch_блока.
Посмотрим ещё один пример. Исключения сильно напоминают goto, можно прыгать и скакать, и всех запутывать, и себя запутать.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//C++ Листинг #3.1 Пустой throw Сброс #include <iostream> using std::cout; void foo_try_container(){ try{ throw 1; //2. Активизируем исключение } catch(...){ //3. Попадаем сюда throw; //4. Выскакиваем из активизированного исключения } } int main(){ try{ foo_try_container(); //1. Вызываем функцию из внешнего try } catch(...){ //5. Попадаем сюда, во внешний обработчик cout << "main_catch\n"; } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//C++ Листинг #3.2 Пустой throw Втаскивание #include <iostream> using std::cout; void foo_catch_container(){ try{ throw; //4. Происходит принудительное втаскивание в обработчик (можно throw 100, разницы не будет) } catch(...){ //5. Попадаем сюда cout << "foo_catch_container"; } } int main(){ try{ throw 1; //1. Детонируется исключение } catch(...){ //2. Попадаем сюда, во внешний обработчик foo_catch_container(); //3. В нём вызывается функция со своим внутренним try-catch_блоком } } |
Ну как, стало лучше видно в чём различие?
Не забывайте, что чтобы можно было "втащить", нужно активизированное исключение. Так, в листинге #3.2 мы сначала активизировали исключение throw 1, после чего сработало всё цепочкой, и только потому что была та активизация, внутри функции foo_catch_container, мы удачно совершили прыжок в catch. Если не активизировать исключение, то получим ошибку времени выполнения:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//C++ Листинг #3.3 Пустой throw Втаскивание, ошибка "нет активного исключения" #include <iostream> using std::cout; void foo_catch_container(){ try{ throw; } catch(...){ cout << "foo_catch_container"; } } int main(){ try{ throw; //1. Попытка влезть в catch, но до этого момента ни одно исключение не сдетонировало, т. е. не активировалось } catch(...){ foo_catch_container(); } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//C++ Листинг #3.4 Пустой throw Сброс #include <iostream> using std::cout; void foo_try_container(){ try{ throw; //2. Попытка заскочить в catch, но на этот момент ни одно исключение не сдетонировало, не было throw } catch(...){ throw; } } int main(){ try{ foo_try_container(); //1. Вызываем функцию из внешнего try } catch(...){ cout << "main_catch\n"; } } |
Случайная книга в электронном формате
Добавить комментарий