Обработка исключительных ситуаций на примере try…catch в С++. Начало знакомства
"Что такое исключения в С++ и как начать их осваивать?" — подобный вопрос может вертеться у новичка в голове. К сожалению, оттолкнуться для старта не у каждого получается быстро. Несмотря на то, что общее представление об исключениях в голове есть, их использовать — некоторые мы не можем.
- Исключения — механизм языков программирования, предназначенный для описания реакции программы на ошибки времени выполнения и другие возможные проблемы, которые могут возникнуть при выполнении программы и приводят к невозможности (бессмысленности) дальнейшей отработки программой её базового алгоритма.
Классические примеры возникновения нештатных ситуаций:
- Деление на ноль
- Ошибка при попытке считать данные с внешнего устройства
- Исчерпание доступной памяти
Для понимания темы требуется знать:
Сейчас напишем простенькую программу с обработкой исключения.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//С++ Исключения Листинг #1 mingw #include <iostream> using std::cout; using std::cin; int main(){ int x = 0; //поменяйте значение на другое, вызовется другое исключение try { if (x == 0) throw ("zero_throw\n"); //Если значение x ноль, то генерируем одно исключение if (x < 0) throw("minus_throw\n"); //Если значение x отрицательное, то генерируем другое исключение if (x > 0) throw("plus throw\n"); //Если значение x положительное, то генерируем третье исключение } catch (const char* S) { cout << S << '\n'; }; } |
Листинг #1 наглядно отображает, каким образом вызываются исключения: делается проверка на определённое условие и с помощью ключевого слова throw идёт посыл своебразного сигнала (обычного значения) в блок catch, предназначенного для обработки исключительных ситуаций. Сейчас сигналом служит обычное строковоое значение. В нашем случае вся обработка — это лишь вывод на экран информации о сработавшем исключении. Отдавать в throw можно хоть объект своего класса. Но и принимать в блок catch следует соответствующий отдаваемому тип. Блок 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 |
//C++ Исключения Листинг #2 mingw Пример подачи в исключение объекта своего класса #include <iostream> using std::cout; using std::cin; class MyClass{ int value; public: MyClass(){}; MyClass(const int value_):value(value_){} //конструктор с параметром для передачи значения-сигнала ошибки в объект void print() const { cout << "signal_value == " << value << '\n';} }; int main(){ int x = -1; //поменяйте значение на 0, вызовется другое исключение MyClass object; try { if (x == 0) throw (object = 0); //Если значение x ноль, то генерируем одно исключение if (x < 0) throw (object = -1); //Если значение x отрицательное, генерируем другое исключение } catch (const MyClass& object) //catch принимает параметр подобно принимающей параметр функции { cout << "block_catch\n"; object.print(); //выводим информацию на экран }; } |
Если вы еще плохо знакомы с классами, то не стоит сейчас пытаться понять листинг #2. В этом листинге используется конвертирующий конструктор, а конструкторы — это само по себе отдельная тема. Если же вы знакомы с понятием конвертирующего конструктора, то пример должен быть для вас достаточно простым и, надеюсь, крайне понятным. Сам этот пример показан только для того, чтобы продемонстрировать, что подаётся в задаваемое исключение некоторое нечто любого типа: необязательно только строка или только целое число, а от объекта того типа уже идут пляски: блок обработки исключения принимает параметр, в этот параметр приходит поданное значение, и этот параметр можно использовать в своих интересах. Например, на основании наших значений, мы могли бы вывести диагностическое сообщение о произошедшей ошибке: если значение оказалось нулём, то это, согласно коду, должно обозначать, что x принял нулевое значение и после проверки на такое событие запустилось соответствующее такому развитию исключение; если же оказалось минус-единицей, то это должно обозначать, что x принял отрицательное значение. Мы могли бы использовать любое другое удобное нам значение для обозначение сигнала ошибки. Тут единственное важно, чтобы пишущий код не запутал себя и дргих какими-нибудь нелогичными закономерностями вида: если нулевое значение, то пусть в исключение пойдёт минус один, а если отрицательное, то пусть пойдёт ноль. Сейчас будет показан гораздо более понятный листинг:
|
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 |
//C++ Исключения Листинг #3 mingw Пример подачи в исключение объекта своего класса #include <iostream> using std::cout; using std::cin; class Bad_A{ public: void info() const { cout << "zero value\n"; } }; class Bad_B{ public: void info() const { cout << "one value\n"; } }; int main(){ int x = 0; try{ if (x == 0) throw(Bad_A()); //Если x нулевое значение — генерируем исключение под тип Bad_A (подаём сигнал-значение в обработчик исключения) else if (x == 1) throw(Bad_B()); //Если x единица — генерируем исключение под ти Bad_B (подаём сигнал-значение в обработчик исключения) } catch(Bad_A value){ //Исключение для сигнал-значения с типом Bad_A value.info(); } catch(Bad_B value){ //Исключение для сигнал-значения с типом Bad_B value.info(); } } |
- Исключение в С++ может иметь любой тип, обычно они имеют тип класса
- Блок catch очень похож на определение функции, но это не функция, это обработчик, а параметром этого обработчика обозначается тип сгенерированного исключения (тип того элемента, который мы подсовываем в throw
Как можно заметить по листингу #3 — с одним try может идти много обработчиков, т. е. много catch. Как уже было упомянуто, в обработчик можно подавать любой тип, и на основании поданного типа срабатывает соответствующий поданному блок обработки исключения. Если использовать несколько блоков обработки и подавать в каждый из них пользовательские классы, то это обычно оказывается очень удобно. Такой приём может быть удобно использовать, например, для отдельных функций: для одной функции один bad-класс, для второй другой bad-класс, для третьей — третий.
То, что показано в листинге #3 может реализовываться следующим образом:
|
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++ Исключения Листинг #3.1 mingw Пример подачи в исключение объекта своего класса #include <iostream> using std::cout; class Age{ //Класс, сейчас обозначает возраст int i; //число, которое и будет возрастом public: void get(const int); class Small{}; //Внутри некоторого класса пустой класс для обработки одной ситуации class Big{}; //Внутри некоторго класса пустой класс для обработки другой ситуации }; void Age::get(const int i){ try{ if (i<0) throw Small(); //Если число-возраст отрицательное, то кидаем соответствующее исключение else if (i>100) throw Big(); //Если число слишком большое, то кидаем соответствующее такому развитию исключение cout << "All OK!\n"; //Если число вошло в диапазон, то всё ОК this->i = i; //Если всё ОК, то записывание значения вовнутрь класса } catch(const Small& ex){ cout << i << " very small\n"; //очень маленькое } catch(const Big& ex){ cout << i << " very big\n"; //очень маленькое } catch(...){ //перехват возникновения неописанных исключений cout << "input error\n"; } } int main(){ Age a; a.get(-5); a.get(10); a.get(200); } |
Вся эта программа из листинга #3.1 включает в себя всего лишь один класс, внутри которого написан метод получения числового значения. По названию класса несложно понять, что нашим классом моделируется переменная-возраст, а поскольку возраст не может быть отрицательным и обычно имеет определённый лимит (для разных живых организмов разный), то ни отрицательное, ни слишком большое число не подходят для записи. Чтобы предупредить развитие событий, когда вовнутрь класса будет подаваться отрицательное или слишком большое число, использован механизм исключений. Во время получения значения происходит проверка, и если что-то идёт не как запланировалось, то бросается исключение на определённое событие. Для удобства обработки под каждый бросок исключения создан индивидуальный тому класс, благодаря чему мы получаем довольно удобный функционал: класс позволяет более гибко выстраивать необходимое поведение, а в само исключение бросается тип по одному из созданных этих классов. Тут важно понимать, что обработка необходимого должна происходить в блоке try: т. е. там и бросаются исключения и описывается, что должно произойти, если предпосылок для исключений не возникнет. Всё, что описано будет вне блока, сработает в штатном режиме, как если бы исключений и не было.
|
1 2 3 4 5 6 7 8 9 |
try{ if (i<0) throw Small(); //Если число-возраст отрицательное, то кидаем соответствующее исключение else if (i>100) throw Big(); //Если число слишком большое, то кидаем соответствующее такому развитию исключение } catch(...){ } cout << "All OK!\n"; //промахнулись, описали вне блока try this->i = i; //сработает, поскольку находится вне зависимости от исключений |
При броске исключений в работе с try…catch не всегда удобно использовать непосредственный тип значения для отслеживания в ловушку-обработчик. Если использовать тип не такой, какой подаётся в бросок исключения, то блок обработки исключения не задействуется:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
//C++ Исключения Листинг #4.1 mingw Пример с ошибкой типа: бросается для обработки не тот, что ловится обработчиком: #include <iostream> #include <exception> using std::cout; int main(){ try{ if (1) throw("ОШИБКА"); //Подаётся для обработки тип { const char* } } catch (int i){ //А ловится тип { int } cout << "catch_block\n"; } //Тип { const char* } не ловится обработчиками } |
Конечно, можно использовать несколько обработчиков, и один из них тогда может схватить нужный тип. Но можете ли вы быть уверены, что завтра будете подавать на отлов исключения уже описанный тип?
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//C++ Исключения Листинг #4.2 mingw Пример с ошибкой типа: бросается для обработки не тот, что ловится обработчиком: #include <iostream> #include <exception> using std::cout; int main(){ try{ if (1) throw("error"); } catch (int i){ //Используем несколько catch cout << "catch_block\n"; cout << "value = " << i << '\n'; } catch (const char* S){ //Но вы уверены, что ожирять код хорошая идея? cout << "catch_block\n"; cout << "value = " << S << '\n'; } //Тип { const char* } не ловится обработчиками } |
Что ожирять код, что постоянно менять — дело неблагодарное, поэтому существуют более удобные альтернативы, виды которых вы будете встречать или уже успели. Одна из таких альтернатив (которую применять НЕ нужно) выглядит так:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
//C++ Исключения Листинг #5 mingw Пример подачи в обработчик исключения специального класса, НЕ рекомендуется #include <iostream> #include <exception> using std::cout; using std::exception; int main(){ try{ throw exception("ОШИБКА"); //условие опущено для краткости кода, бросаем в исключение тип exception } //используя конструктор этого типа, пишем в него текстовую информацию catch (const exception &ex){ //ловим обработчиком тип exception (всё также, как в параметрах функций) cout << "catch_block\n"; cout << "value = " << ex.what() << '\n'; //используем метод what() объекта ex. ex — это обычная переменная - объект класса, можно назвать иначе } } |
Почему не рекомендуется? Некоторые уверяют, что даже надо. Всё очень просто — это не из языка С++, это расширение некоторого компилятора: в одном компиляторе работать будет, а в другом — нет, не будет компилироваться. Если вы напишете много кода, а потом возникнет необходимость смены компилятора, то может прийтись переписывать участки кода из-за отсутствия расширения в новопользуемом, например. Можно использовать или exception с пустыми скобками, или не использовать этот класс вообще. Если использовать класс с пустыми круглыми скобками, то мы не можем самостоятельно подать элемент информирования вовнутрь обработчика. Но если этот элемент прям жизненно необходим, то предпочтение надо отдать или logic_error, или runtime_error. Эти два "бойца" умеют принимать в свои конструкторы данные, поэтому мы в подаче на обработку исключения смело можем этим пользоваться.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
//C++ Исключения Листинг #5.1 mingw Используем logic_error #include <iostream> #include <exception> using std::cout; using std::logic_error; int main(){ int i = 10; try{ if (i) throw logic_error("error"); } catch (const logic_error &ex){ //Обратите внимание, что тип отлова изменился: стал const logic_error& cout << "catch_block\n"; //сейчас мы ловим тип logic_error& cout << "value = " << ex.what() << '\n'; } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
//C++ Исключения Листинг #5.2 mingw Используем runtime_error #include <iostream> #include <exception> using std::cout; using std::cin; using std::runtime_error; int main(){ int i = 0; try{ cout << "input i: "; cin >> i; if (cin.fail()) throw (runtime_error("input error: strint in i")); //или runtime_error("error"); } catch (const runtime_error &ex){ //Обратите внимание, что тип отлова изменился cout << "catch_block\n"; //теперь мы ловим тип runtime_error cout << "value = " << ex.what() << '\n'; } } |
Я не могу грамотно описать, когда рантайм, а когда логик, поэтому опущу этот момент. Эта статья больше предназначена быть точкой входа в понимание использование обработки исключительных ситуаций вообще. Об исключениях можно ещё писать, но если прочтение вами этой статьи включило тумблер осознания, что это вообще такое, то своей цели я добился. В совокупности с другими статьями или текстами учебников, вы обязательно освоите этот элемент языка.
Случайная книга в электронном формате
Добавить комментарий