C++ Program to Handle the Exception Methods
Exception handling is a manner to handle the runtime error, we carry out exception handling, so, the normal flow of the program may be maintained even after runtime errors. Exceptions are runtime anomalies or abnormal conditions that a program encounters during its execution.
The Exception Handling mechanism offers a way to transfer control from one part of a program to another, This makes it clean to separate the mistake handling code from the code written to address the real functionality of the program.
C++ provides the following specialized keywords for exception handling:
- try: A block of code that may throw an exception is typically placed inside the try block, It’s followed by one or extra seize blocks. If an exception happens, it is thrown from the try block.
- catch: This block catches the exception thrown from the try block, code to address the exception is written inside this catch block.
- throw: throw keyword is used to throw an exception. Also used to list the exceptions that a function throws but doesn’t handle itself.
Syntax:
try
{
// Block of code to try
// Throw an exception when a problem arise
throw exception;
}
catch ()
{
// Block of code to handle errors
}
Below are the C++ programs to show how exceptions are handled in C++:
Example 1: Below is the C++ program to show what happens when division by zero is done and exceptions are not handled.
C++
// C++ program to show what happens // when division by zero is done // and exceptions are not handled #include <iostream> using namespace std; // Driver code int main() { int numerator = 5; int denominator = 0; int ans = numerator/denominator; // The result will not be displayed cout << ans << endl; return 0; } |
Output:
Floating-point exception (SIGFPE)
The above program will show an abnormal behavior and the output will not be displayed. An exception is being thrown in the code but it is not being caught so either it will show a floating-point exception or not display any output.
Below is the C++ program to handle divide by zero exception:
C++
// C++ program to handle // divide by zero exception #include <iostream> using namespace std; // Driver code int main() { int numerator = 5; int denominator = 0; int result; try { if (denominator == 0) { throw denominator; } result = numerator / denominator; } catch ( int ex) { cout << "Exception: Divide by zero not allowed :" << ex << endl; } cout << "Division Result is: " << result; return 0; } |
Exception: Divide by zero not allowed :0 Division Result is: 4197440
Example 2: Below is the C++ program to input an age integer if the age is less than 18 then return NO, but if the age is greater than or equal to 18 then return Yes:
C++
// C++ program to input an age integer // if the age is less than 18 then // return NO, but if the age is greater // than or equal to 18 then return Yes #include <iostream> using namespace std; // Driver code int main() { try { int age = 10; if (age >= 18) { cout << "YES, you are old enough." ; } else { throw (age); } } catch ( int num) { cout << "No, You must be at least 18 years old" << endl; cout << "Age is: " << num; } return 0; } |
No, You must be at least 18 years old Age is: 10
C++ Standard Exceptions
C++ defines a set of standard exceptions defined in <exception> which can be used in the programs. These exceptions are arranged in the parent-child class hierarchy. Below is the table listing the standard exceptions with description:
S.No. | Exception | Description |
---|---|---|
1. | std::exception | An exception and parent class of all the standard C++ exceptions. |
2. | std::bad_alloc | This exception can be thrown by new. |
3. | std::bad_cast | This exception can be thrown by dynamic_cast. |
4. | std::bad_exception | This exception is a useful device to handle unexpected exceptions in a C++ program. |
5. | std::bad_typeid | This can be thrown by type id. |
6. | std::logic_error | An exception that can be detected by reading the code. |
7. | std::domain_error | This is an exception thrown when a mathematically invalid domain is used. |
8. | std::invalid_argument | This exception is thrown due to invalid arguments. |
9. | std::length_error | This exception is thrown when a too big std::string is created. |
10. | std::out_of_range | This can be thrown by the ‘at’ method, for example a std::vector and std::bitset<>::operator[](). |
11. | std::runtime_error | An exception that theoretically cannot be detected by reading the code |
12. | std::overflow_error | This is thrown if a mathematical overflow occurs. |
13. | std::range_error | This occurs when you try to store a value that is out of range. |
14. | std::underflow_error | This is thrown if a mathematical underflow occurs. |
New Exception in C++
The customized exceptions can be defined by inheriting and overriding exception class functionality.
Syntax:
use std::exception
Below is the C++ program to define a new exception:
C++
// C++ program to define a // new exception #include <iostream> #include <exception> using namespace std; struct Exceptions : public exception { const char * Except() const throw () { return "w3wiki" ; } }; // Driver code int main() { try { throw Exceptions(); } catch (Exceptions& it) { cout << "Customised Exception caught" << endl; cout << it.Except() <<endl; } catch (std::exception& it) {} } |
Customised Exception caught w3wiki
Contact Us