Как обрабатывать исключения в С++: что такое throw, try и catch
При выполнении кода на C++ могут возникать разные ошибки, которые не позволяют программе выполнять свою работу. Для работы с ошибками или исключениями в C++ используются ключевые слова try , catch и throw .
Ефективний курс від skvot: Основи 3D-моделювання в ZBrush.
Звільніть свою творчість.
Содержание статьи:
Освітній курс від laba: PR-комунікації.
Побудуйте успішний образ вашого бренду.
Вступление: виды исключений и знакомство с try, catch и throw в C++
Есть два вида исключений, с которыми вы можете столкнуться в процессе:
- Синхронные исключения. Этот тип ошибок программа может контролировать сама. Например, ошибки в коде, допущенные программистом или неправильные параметры ввода.
- Асинхронные исключения. Этот тип ошибок не связан напрямую с кодом и программа не может их контролировать. Например, это может быть сбой диска, ошибка при открытии файла, сокета, выделения блока памяти.
Когда происходит какое-то событие, прерывающее нормальное функционирование программы, C ++ обычно останавливается и выдает сообщение об ошибке. Когда это происходит, говорят, что C++ выбрасывает ошибку — throw an exception. Мы уже упоминали, что для работы с ошибками или исключениями в C++ используются определенные ключевые слова, давайте познакомимся с ними поближе:
Освітній курс від robotdreams: Аналітик даних.
Перетворюйте дані на рішення.
- try : позволяет определить блок кода, который будет проверяться на наличие ошибок во время его выполнения;
- throw : нужен для создания и отображения исключений и используется для перечисления ошибок, которые генерирует функция, но не может самостоятельно обрабатывать исключения;
- catch — блок кода, который выполняется при возникновенииопределенного исключения в блоке try .
Давайте посмотрим, как выглядит пример кода в С++ с использованием try catch и throw :
try < int age = 15; if (age >= 18) < cout else < throw (age); >> catch (int myNum)
Вкратце объясним, как работают операторы try и catch в С++ на примере этого блока . Мы используем блок try для тестирования определенных строк кода: если переменная age меньше 18, мы генерируем исключение и обрабатываем его в блоке catch .
С помощью catch мы перехватываем ошибку и прописываем способ ее обработки. Оператор принимает параметр: в примере используется переменная типа int myNum для вывода значения возраста.
Если все данные соответствуют установленным параметрам, то ошибки не возникает. Например, если указанный возраст будет больше 18, а не 15, как указано в примере, то блок catch просто пропускается.
Если ошибка присутствует, то оператор throw выбросит ошибку. В throw можно прописать любое значение и оператор может выдать текст с пояснением, например:
Access denied - You must be at least 18 years old. Age is: 15
Или установить числовое значение, например, то код ошибки будет выглядеть следующим образом:
Access denied - You must be at least 18 years old. Error number: 505
После такой большой вводной части подробно рассмотрим генерацию исключений и как их обрабатывать, примеры использования try и catch в С++, подробно расскажем про задачи операторов.
Професійний курс від mate.academy: Python Вечірній.
Поглиблене вивчення Python.
Генерируем исключения в C++
Исключения могут быть выброшены в любом месте кода. Для этого в блоке нужно прописать throw .
Этот оператор определяет тип исключения и может быть любым выражением. Также throw сигнализирует об ошибке в коде и выводит исключение в консоль.
Помимо использования оператора throw , есть еще один способ мониторить ошибки в коде. Он более традиционный, но давайте рассмотрим и его, чтобы лучше понять механику обработки ошибок с помощью операторов.
Обычно мы разбиваем программу на несколько функций или подпрограмм, чтобы сделать ее читабельной и простой для понимания. Получается, что программа будет иметь связанные вызовы функций. То есть одна функция использует ту информацию, которую ей предоставляет другая функция.
Здесь возникают основные проблемы с обработкой ошибок при использовании оператора if :
- Все задействованные функции должны возвращать одни и те же типы данных, например, целые числа. Из-за этого код становится длинным и громоздким, потому что приходится возвращать один и тот же вид данных.
- Глобальную переменную нужно проверить сразу же после вызова функции в обработчике или кэшировать. Потому что она может обновиться, если в дальнейшем произойдет другая ошибка.
- Обработка ошибки зависит от вызывающей стороны. Если исключение не обработать, оно может вызвать сбой в программе позже или программа продолжит работу неправильно.
Вот так выглядит обработка ошибок в коде при использовании оператора if :
unsigned int error_type = 0; int add(int a, int b) < if (a >100 || b > 100) < error_type = 1; return -1; >else if (a < 0 || b < 0) < error_type = 2; return -1; >return a + b; > int add_wrapper(int a, int b) < return add(a, b); >int main(int, char**) < if (add_wrapper(-1, 8) < 0) < if (error_type == 1) < std::cout else < std::cout = 0" > else < std::cout << "add operation succeeded" return 0; >
А вот так будет выглядеть код с использованием try и catch в С++ (example):
#include using namespace std; class Test < public: Test() < cout ~Test() < cout >; int main() < try < Test t1; throw 10; >catch (int i) < cout >
По сравнению с несколькими строками кода в случае try и catch в С++ , предыдущий блок выглядит очень перегруженным и длинным. В целом при использовании оператора if обработка ошибок и программный код тесно взаимосвязаны. Из-за этого код становится беспорядочным, и трудно гарантировать, что все ошибки будут обработаны и программа будет работать нормально.
Метод try / catch , в свою очередь, обеспечивает четкое разделение между кодом, который знает об ошибке, и кодом, который знает, как обрабатывать ошибку. Таким образом, код, который находятся между этими операторами, может безопасно игнорировать ошибку.
Поэтому, запуская код в С++ Builder, лучше искать исключения с помощью try , catch и throw . Это сделает ваш код проще, чище и с меньшей вероятностью вы допустите ошибки в программе.
Ищем ошибки в коде
Для того чтобы проверить блок кода на ошибки и аномалии, используется оператор try . Так мы можем быть уверены, что если появится исключение в этой части кода, то try его заметит. Главная особенность оператора в том, что в отличие от if / else , которые смешиваются с обычным потоком данных, try отделяет обработку ошибок от обычного течения программы.
Блок try помещается вокруг кода, который может генерировать исключение, и закрывается другим оператором этой пары — catch . Код в блоке try / catch называется защищенным кодом , а синтаксис для использования связки этих операторов выглядит следующим образом:
try < // protected code >catch( ExceptionName e1 ) < // catch block >catch( ExceptionName e2 ) < // catch block >catch( ExceptionName eN ) < // catch block >
С помощью метода try / catch можно перечислить и поймать сразу несколько видов исключений, если блок try вызывает несколько типов ошибок в разных ситуациях. Несмотря на то, что функция может генерировать множество исключений, вы можете обрабатывать не все, а только некоторые из них.
Обрабатываем ошибки с try и catch in С++
Блок catch , идущий в паре с оператором try , ловит и обрабатывает исключения. Чтобы указать, какой тип исключения вы хотите поймать и обработать, нужно прописать это в скобках после ключевого слова catch :
try < // protected code >catch( ExceptionName e ) < // code to handle ExceptionName exception >
Приведенный выше код перехватит только исключение типа ExceptionName . Если вы хотите указать, что блок catch должен обрабатывать любой тип ошибок, который находит оператор try , просто поместите многоточие . между скобками:
try < // protected code >catch(. ) < // code to handle any exception >
Рассмотрим пример кода, в котором генерируется исключение деления на ноль:
#include using namespace std; double division(int a, int b) < if( b == 0 ) < throw "Division by zero condition!"; >return (a/b); > int main () < int x = 50; int y = 0; double z = 0; try < z = division(x, y); cout catch (const char* msg) < cerr return 0; >
Так как программа вызывает тип исключения const char * , в блоке catch необходимо указать const char * , чтобы ошибку можно было определить и обработать. Если скомпилировать и запустить этот блок кода, то в результате получим условие прописанное в throw :
Division by zero condition!
Как работают throw, try и catch в C++: примеры
Рассмотрим на примерах, как между собой взаимодействуют операторы throw , try и catch в С++. В блоке кода ниже приведен простой пример, демонстрирующий обработку исключений. Результат программы наглядно покажет, в какой последовательности происходит выполнение операторов :
#include using namespace std; int main() < int x = -1; // Some code cout > catch (int x ) < cout cout
В результате получается следующая последовательность:
Before try Inside try Exception Caught After catch (Will be executed)
Нужно не забывать прописывать одинаковые типы исключений в try / catch . Если исключение одного типа будет выброшено, а catch не сможет его поймать и обработать, то программа завершается ненормально:
#include using namespace std; int main() < try < throw 'a'; >catch (int x) < cout return 0; >
В этом примере кода исключение является символом, но блок catch для захвата символа отсутствует. В результате блок вернет нам не исключение, а вот такое предупреждение:
terminate called after throwing an instance of 'char' This application has requested the Runtime to terminate it in an unusual way. Please contact the application's support team for more information.
С помощью try / catch можно указывать кастомные типы исключений, наследуя и переопределяя функциональность класса исключений. В примере ниже приведем код, который покажет, как вы можете использовать класс std :: exception для генерации собственной ошибки стандартным способом :
#include #include using namespace std; struct MyException : public exception < const char * what () const throw () < return "C++ Exception"; >>; int main() < try < throw MyException(); >catch(MyException& e) < std::cout catch(std::exception& e) < //Other errors >>
Результат выполнения кода выглядит так:
MyException caught C++ Exception
Еще немного о порядке обработке ошибок в C++
Когда мы прописываем операторы try / catch в коде, то исключение выбрасывается только при исполнении определенных условий. Рассмотрим как работают try , catch и throw в С++ на примере:
#include // for sqrt() function #include int main() < std::cout ; std::cin >> x; try // Ищет исключения в блоке и направляет их к обработчику catch < // этот блок сработает, если пользователь ввел отрицательное число if (x < 0.0) throw "Can not take sqrt of negative number"; // throw выбрасывает исключение типа const char* // Если пользователь ввел число больше 0, то выполняется этот блок кода std::cout catch (const char* exception) // обработчик исключений типа const char* < std::cerr >
Пользователь может ввести число больше нуля, как и задумано. Тогда программа просто продолжит работать в нормальном режиме и пропустит блок с оператором catch . Допустим, пользователь ввел число 49. Тогда результат выполнения кода будет следующим:
Enter a number: 49 The sqrt of 49 is 7
Но пользователи не всегда действуют так, как задумывал разработчик. Поэтому оператор catch нужен нам для того, чтобы программа не сломалась от непредвиденных значений, а могла нормально функционировать и дальше. Поэтому если пользователь введет число меньше нуля, то после того, как try обнаружит непредусмотренное значение, заработают операторы catch и throw , и программа выдаст такое значение:
Enter a number: -4 Error: Can not take sqrt of negative number
Таким образом, строки кода с catch и throw выполняются только тогда, когда try обнаруживает исключение в коде. Если все данные удовлетворяют условиям кода, то блок с исключениями просто пропускается программой.
Подводим итоги
Как использовать try , catch и throw в С++, мы разобрались. Теперь кратко напомним, зачем все это нужно:
- В первую очередь, код с try / catch занимает меньше строк и легче читается. Блоков с операторами if / else может быть очень много и они будут повторяться, тогда как try / catch содержит только два блока.
- Исключения C++ заставляют код определять условия ошибки и обрабатывать исключения. Это позволяет не останавливать выполнение программы.
- После обнаружения исключения код на C++ перестает считывать объекты в блоке кода, сокращая использование программных ресурсов.
- Получение понятного сообщения об ошибке сильно упрощает процесс исправления бага. Особенно это полезно в случае, если исключение выбрасывается не из-за написанного кода, а, к примеру, из-за использованной библиотеки.
- Типы ошибок в C++ можно группировать вместе, что позволяет создавать иерархию объектов исключений, группировать их по именам, классам и категоризировать по виду.
Видео: С++ try catch. Обработка исключений С++. Try catch: что это. Изучение С++ для начинающих
Обработка исключений в C++
Язык С представляет программисту очень ограниченные возможности обработки исключений, возникших при работе программы. В этом отношении С++ намного развитее С. Здесь у программиста существенно большие возможности по непосредственной обработке исключений. Комитет по разработке стандартов С++ предоставил очень простую, но мощную форму обработки исключений.
Темные дни С
Типичная функция, написанная на С, выглядит примерно так:
long DoSomething() < long *a, c; FILE *b; a = malloc(sizeof(long) * 10); if (a == NULL) return 1; b = fopen("something.bah", "rb"); if (b == NULL) < free(a); return 2; >fread(a, sizeof(long), 10, b); if (a[0] != 0x10) < free(a); fclose(b); return 3; >fclose(b); c = a[1]; free(a); return c; >
Выглядит не очень, не так ли? Вы целиком и полностью зависите от значений, которые возвращают вам функции и для каждой ошибки вам постоянно нужен код, который ее обрабатывает. Если вы, скажем, в функции работаете хотя бы с 10 указателями (рапределяете память, освобождаете ее и т.д.), то наверняка половину кода функции будет занимать код обработки ошибок. Такая же ситуация будет в коде, вызывающем эту функцию, так как здесь также нужно обработать все возвращаемые коды ошибок.
Try-catch-throw
Давайте же разберем основы обработки исключений в С++. Чтобы комфортно работать с исключениями в С++ вам нужно знать лишь три ключевых слова:
- try (пытаться) — начало блока исключений;
- catch (поймать) — начало блока, «ловящего» исключение;
- throw (бросить) — ключевое слово, «создающее» («возбуждающее») исключение.
А теперь пример, демонстрирующий, как применить то, что вы узнали:
void func() < try < throw 1; >catch(int a) < cout cout
Если выполнить этот фрагмент кода, то мы получим следующий результат:
Caught exception number: 1
Теперь закоментируйте строку throw 1; и функция выдаст такой результат:
No exception detected!
Как видите все очень просто, но если это применить с умом, такой подход покажется вам очень мощным средством обработки ошибок. Catch может «ловить» любой тип данных, так же как и throw может «кинуть» данные любого типа. Т.е. throw AnyClass(); будет правильно работать, так же как и catch (AnyClass &d) <>;.
Как уже было сказано, catch может «ловить» данные любого типа, но вовсе не обязательно при это указывать переменную. Т.е. прекрасно будет работать что-нибудь типа этого:
catch(dumbclass)
catch(dumbclass&)
Так же можно «поймать» и все исключения:
catch(. )
Троеточие в этом случае показывает, что будут пойманы все исключения. При таком подходе нельзя указать имя переменной. В случае, если «кидаются» данные нестандартного типа (экземпляры определенных вами классов, структур и т.д.), лучше «ловить» их по ссылке, иначе вся «кидаемая» переменная будет скопирована в стек вместо того, чтобы просто передать указатель на нее. Если кидаются данные нескольких типов и вы хотите поймать конкретную переменную (вернее, переменную конкретного типа), то можно использовать несколько блоков catch, ловящих «свой» тип данных:
try < throw 1; // throw 'a'; >catch (long b) < cout catch (char b) < cout "
Создание" исключений
Когда возбуждается исключительная ситуация, программа просматривает стек функций до тех пор, пока не находит соответствующий catch. Если оператор catch не найден, STL будет обрабатывать исключение в стандартном обработчике, который делает все менее изящно, чем могли бы сделать вы, показывая какие-то непонятные (для конечного пользователя) сообщения и обычно аварийно завершая программу.
Однако более важным моментом является то, что пока просматривается стек функций, вызываются деструкторы всех локальных классов, так что вам не нужно забодиться об освобождении памяти и т.п.
Перегрузка глобальных операторов new/delete
А сейчас хотелось бы отправить вас к статье "Как обнаружить утечку памяти". В ней рассказывается, как обнаружить неправильное управление распределением памяти в вашей программе. Вы можете спросить, при чем тут перегрузка операторов? Если перегрузить стандартные new и delete, то открываются широкие возможности по отслеживанию ошибок (причем ошибок часто критических) с помощью исключений. Например:
char *a; try < a = new char[10]; >catch (. ) < // a не создан - обработать ошибку распределения памяти, // выйти из программы и т.п. >// a успешно создан, продолжаем выполнение
Это, на первый взгляд, кажется длиннее, чем стандартная проверка в С "а равен NULL?", однако если в программе выделяется десяток динамических переменных, то такой метод оправдывает себя.
Операторы throw без параметров
Итак, мы увидели, как новый метод обработки ошибок удобен и прост. Блок try-catch может содержать вложенные блоки try-catch и если не будет определено соответствующего оператора catch на текущем уровен вложения, исключение будет поймано на более высоком уровне. Единственная вещь, о которой вы должны помнить, - это то, что операторы, следующие за throw, никогда не выполнятся.
try < throw; // ни один оператор, следующий далее (до закрывающей скобки) // выполнен не будет >catch(. )
Такой метод может применяться в случаях, когда не нужно передавать никаких данных в блок catch.
Приложение
Приведем пример, как все вышеизложенное может быть использовано в конкретном приложении. Преположим, у вас в программе есть класс cMain и экземпляр этого класса Main: class cMain < public: bool Setup(); bool Loop(); // Основной цикл программы void Close(); >; cMain Main;
А в функции main() или WinMain() вы можете использовать этот класс как-нибудь так:
try < Main.Setup(); Main.Loop(); Main.Close(); >catch (Exception &e) < // использование класса, ведущего лог. log("Exception thrown: %s", e.String()); // Показываем сообщение об ошибке и закрываем приложение. >
Основной цикл программы может выглядеть примерно так:
while (AppActive) < try < // какие-то действия >catch (Exception &e) < /* Если исключение критическое, типа ошибки памяти, посылаем исключение дальше, в main(), оператором throw e; или просто throw. Если исключение некритично, обрабатываем его и возвращаемся в основной цикл. */ >>
Заключение
Метод обработки исключений, приведенный в статье, является удобным и мощным средством, однако только вам решать, использовать его или нет. Одно можно скачать точно - приведенный метод облегчит вам жизнь. Если хотите узнать об исключениях чуть больше, посмотрите публикацию Deep C++ на сервере MSDN.
Throw c что это
Обычно система сама генерирует исключения при определенных ситуациях, например, при делении числа на ноль. Но язык C# также позволяет генерировать исключения вручную с помощью оператора throw . То есть с помощью этого оператора мы сами можем создать исключение и вызвать его в процессе выполнения.
Например, в нашей программе происходит ввод имени пользователя, и мы хотим, чтобы, если длина имени меньше 2 символов, то возникало исключение:
try < Console.Write("Введите имя: "); string? name = Console.ReadLine(); if (name== null || name.Length < 2) < throw new Exception("Длина имени меньше 2 символов"); >else < Console.WriteLine($"Ваше имя: "); > > catch (Exception e) < Console.WriteLine($"Ошибка: "); >
После оператора throw указывается объект исключения, через конструктор которого мы можем передать сообщение об ошибке. Естественно вместо типа Exception мы можем использовать объект любого другого типа исключений.
Затем в блоке catch сгенерированное нами исключение будет обработано.
Подобным образом мы можем генерировать исключения в любом месте программы. Но существует также и другая форма использования оператора throw, когда после данного оператора не указывается объект исключения. В подобном виде оператор throw может использоваться только в блоке catch:
try < try < Console.Write("Введите имя: "); string? name = Console.ReadLine(); if (name == null || name.Length < 2) < throw new Exception("Длина имени меньше 2 символов"); >else < Console.WriteLine($"Ваше имя: "); > > catch (Exception e) < Console.WriteLine($"Ошибка: "); throw; > > catch (Exception ex)
В данном случае при вводе имени с длиной меньше 2 символов возникнет исключение, которое будет обработано внутренним блоком catch. Однако поскольку в этом блоке используется оператор throw, то исключение будет передано дальше внешнему блоку catch, который получит то же самое исключение и выведет то же самое сообщение на консоль.
Исключения
В процессе работы программы могут возникать различные ошибки. Например, при передаче файла по сети оборвется сетевое подключение или будут введены некорректные и недопустимые данные, которые вызовут падение программы. Такие ошибки еще называются исключениями. Исключение представлякт временный объект любого типа, который используется для сигнализации об ошибке. Цель объекта-исключения состоит в том, чтобы передать информацию из точки, в которой произошла ошибка, в код, который должен ее обработать. Если исключение не обработано, то при его возникновении программа прекращает свою работу.
Например, в следующей программе происходит деление чисел:
#include double divide(int a, int b) < return a / b; >int main() < int x; int y<>; double z
Эта программа успешно скомпилируется, но при ее выполнении возникнет ошибка, поскольку в коде производится деление на ноль, после чего программа аварийно завершится.
С одной стороны, мы можем в функции divide определить проверку и выполнять деление, если параметр b не равен 0. Однако нам в любом случае надо возвращать из функции divide некоторый результат - некоторое число. То есть мы не можем просто написать:
double divide(int a, int b) < if (b) return a / b; else std::cout
И в этом случае нам надо известить систему о возникшей ошибке. Для этого используется оператор throw .
Оператор throw генерирует исключение. Через оператор throw можно передать информацию об ошибке. Например, функция divide могла бы выглядеть следующим образом:
double divide(int a, int b) < if (b) return a / b; throw "Division by zero!"; >
То есть если параметр b равен 0, то генерируем исключение.
Но это исключение еще надо обработать в коде, где будет вызываться функция divide. Для обработки исключений применяется конструкция try. catch . Она имеет следующую форму:
try < инструкции, которые могут вызвать исключение >catch(объявление_исключения)
В блок кода после ключевого слова try помещается код, который потенциально может сгенерировать исключение.
После ключевого слова catch в скобках идет параметр, который передает информацию об исключении. Затем в блоке производится собственно обработка исключения.
Так изменим весь код следующим образом:
#include double divide(int a, int b) < if (b) return a / b; throw "Division by zero!"; >int main() < int x; int y<>; try < double z Код, который потенциально может сгенерировать исключение - вызов функции divide помещается в блок try. В блоке catch идет обработка исключения. Причем многоточие в скобках после оператора catch ( catch(. ) ) позволяет обработать любое исключение. В итоге когда выполнение программы дойдет до строки При выполнении этой строки будет сгенерировано исключение, поэтому последующие инструкции из блока try выполняться не будут, а управление перейдет в блок catch, в котором на консоль просто выводится сообщение об ошибке. После выполнения блока catch программа аварийно не завершится, а продолжит свою работу, выполняя операторы после блока catch: Однако в данном случае мы только знаем, что произошла какая-то ошибка, а какая именно, неизвестно. Поэтому через параметр в блоке catch мы можем получить то сообщение, которое передается оператору throw : #include >iostream < double divide(int a, int b) < if (b) return a / b; throw "Division by zero!"; >int main() < int x; int y<>; try < double z С помощью параметра const char* error_message получаем сообщение, которое предано оператору throw, и выводим это сообщение на консоль. Почему здесь мы получаем сообщение об ошибке в виде типа const char* ? Потому что после оператора throw идет строковый литерал, который представляет как раз тип const char* . И в этом случае консольный вывод будет выглядеть следующим образом: Таким образом, мы можем узнать суть возникшего исключения. Подобным образом мы можем передавать информацию об исключении через любые типы, например, std::string: Тогда в блоке catch мы можем получить эту информацию в виде объекта std::string : catch (std::string error_message) Если же исключение не обработано, то вызывается функция std::terminate() (из модуля стандартной библиотеки C++), которая, в свою очередь, по умолчанию вызывает другую функцию - std::abort() (из ), которая собственно и завершает программу. Существует очень много функций и в стандартной библиотеке С++, и в каких-то сторонних библиотеках. И может возникнуть вопрос, какие из них вызывать в конструкции try-catch, чтобы не столкнуться с необработанным исключением и аварийным завершением программы. В этом случае может помочь прежде всего документация по функции (при ее наличии). Другой сигнал - ключевое слово noexcept , которое при использовании в заголовке функции указывает, что эта функция никогда не будет генерировать исключения. Например: Здесь указываем, что функция print() никогда не вызовет исключение. Таким образом, встретив функцию с подобным ключевым словом, можно ожидать, что она не вызовет исключения. И соответственно нет необходимости помещать ее вызов в конструкцию try-catch. При обработке исключения стоит помнить, что при передаче объекта оператору throw блок catch получает копию этого объекта. И эта копия существует только в пределах блока catch. Для значений примитивных типов, например, int , копирование значения может не влиять на производительность программы. Однако при передаче объектов классов издержки могут выше. Поэтому в этом случае объекты обычно передаются по ссылке, например: #include double divide(int a, int b) < if (b) return a / b; throw std::string; > int main() < int x; int y<>; try < double z Мы можем генерировать и обрабатывать несколько разных исключительных ситуаций. Допустим, нам надо, чтобы при делении делитель был меньше делимого: В функции divide в зависимости от значения числа b оператору throw передаем либо число: либо строковый литерал: Для тестирования функции divide определена другая функция - test, где вызов функции divide() помещен в конструкцию try..catch . Поскольку при генерации исключения мы можем получать ошибку в виде двух типов - int (если b равно 0) и const char* (если b больше a), то для обработки каждого типа исключений определены два разных блока catch: catch (int code) < std::cout catch (const char* error_message)
В функции main вызываем функцию test, передавая в нее различные числа. При вызове: число b не равно 0 и меньше a, поэтому никаких исключений не возникает, блок try срабатывает до конца, и функция завершает свое выполнение. При втором вызове число b равно 0, поэтому генерируется исключение, а в качестве объекта исключения передается число 0. Поэтому при возникновении исключения программа выберет тот блок catch, где обрабатывается исключения типа int: catch (int code) При третьем вызове число b больше a, поэтому объект исключения будет представлять строковый литерал или const char* . Поэтому при возникновении исключения программа выберет блок catch, где обрабатывается исключения типа const char*: catch (const char* error_message) Таким образом, в данном случае мы получим следующий консольный вывод: Может быть ситуация, когда генерируется исключение внутри конструкции try-catch , и даже есть блок catch для обработки исключений, однако он обрабатывает другие типы исключений: Здесь нет блока catch для обработки исключения типа int . Поэтому при генерации исключения: Программа не найдет нужный блок catch для обработки исключения, и программа аварийно завершит свое выполнение. Стоит отметить, что, если в блоке try создаются некоторые объекты, то при возникновении исключения у них вызываются деструкторы. Например: В классе Person определяет деструктор, который выводит сообщение на консоль. В функции print просто генерируем исключение. В функции main в блоке try создаем один объект Person и вызываем у него функцию print, что естественно приведет к генерарции исключения и переходу управления программы в блок catch . И если мы посмотрим на консольный вывод то мы увидим, что прежде чем начнется обработка исключения в блоке catch, будет вызван деструктор объекта Person.double z
Error! The End.
Division by zero! The End.
throw std::string;
void print(int argument) noexcept;
Создание объекта исключения
Обработка и генерация разных типов исключений
#include double divide(int a, int b) < if(!b) // если b == 0 < throw 0; >if(b > a) < throw "The first number is greater than the second one"; >return a / b; > void test(int a, int b) < try < double result
throw 0;
throw "The first number is greater than the second one";
test(100, 20); // 5
test(100, 0); // Error code: 0
test(100, 1000); // The first number is greater than the second one
5 Error code: 0 The first number is greater than the second one
void test(int a, int b) < try < double result
throw 0;
try-catch и деструкторы
#include class Person < public: Person(std::string name) :name< name > < std::cout ~Person() < std::cout void print() < throw "Print Error"; >private: std::string name; >; int main() < try < Person tom< "Tom" >; tom.print(); // Здесь генерируется ошибка > catch (const char* error) < std::cerr >
Person Tom created Person Tom deleted Print Error