try…catch Пустой throw

Опубликовано 16.08.2019 | Автор: admin

Есть такое неофициальное понятие, как "пустой throw". Сейчас мы немного узнаем, что это такое.

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

//C++		Листинг 0.0		Пустой throw
int main(){
	try{
	
	}
	catch(...){
		throw;		// <--		Пустой throw
	}
}

//C++ Листинг 0.0 Пустой throw

int main(){

try{

}

catch(...){

throw; // <-- Пустой throw

}

У этой операции есть два назначения:

Выход из цепочки работающих обработчиков детонируемых
throw
Втаскивание хода работы в блок-обработчик исключительной ситуации

Поскольку на словах скорее всего трудно понять, что это должно значить, посмотрим на несколько примеров. Начнём со сброса. Иногда в некоторый try-catch вкладывают другой try-catch. И бывает, что нужно деактивизировать вложенный try-catch и продолжить работу во внешнем обработчике. Писать как-то сложнее, чем демонстрировать кодом, поэтому посмотрим на код для выяснения, о чём я пытаюсь рассказать:

//С++		Листинг #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";			//в котором продолжаем какую-то деятельность
    }
}
//

//С++ Листинг #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)

//C++				Листинг #1.2		Пустой throw без внешнего try-catch
int main(){


   //Внешний try-catch  отсутствует
           try{
                throw 1;
           }
           catch(...){
               cout << "catch_attachment\n";
            throw;      //Попытка сброса приводит к ошибке "неперехваченное исключение"
           }

}

//C++ Листинг #1.2 Пустой throw без внешнего try-catch

int main(){

//Внешний try-catch отсутствует

try{

throw 1;

}

catch(...){

cout << "catch_attachment\n";

throw; //Попытка сброса приводит к ошибке "неперехваченное исключение"

}

Кто-то из моих читателей может подумать, что "ага, всё понятно", но даже если и так, то не советую торопиться с выводами. Новичку запутаться очень несложно. Например, воспроизводя в коде программы текст обработки исключительной ситуации с попыткой сброса, новичок может написать что-то эдакое:

//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";
    }
}

//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 от первого сдетонировавшего исключения:

//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";
   }
}

//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_тип должно "сдетонировать". Поскольку мои слова только всё усложнят, начнём с изучения примера:

//С++		Листинг #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"; //в него нас и втаскивает
        }
    }
}

//С++ Листинг #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, можно прыгать и скакать, и всех запутывать, и себя запутать.

//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";
    }
}

//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";

}

//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_блоком
    }
}

//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. Если не активизировать исключение, то получим ошибку времени выполнения:

//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(); 
    }
}

//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();

}

//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";
    }
}

//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";

}

Рубрика: Исключения

try…catch Пустой throw

Добавить комментарий Отменить ответ

Поиск

Последние темы

Случайная книга в электронном формате

Последние комментарии

Мета