C++ Exception Handling

An exception is a problem that arises during the execution of a program. A C++ exception is a response to an exceptional circumstance that arises while a program is running, such as an attempt to divide by zero.Exceptions provide a way to transfer control from one part of a program to another.

C++ exception handling is built upon three keywords: try, catch, and throw.

throw: A program throws an exception when a problem shows up. This is done using a throw keyword.
catch: A program catches an exception with an exception handler at the place in a program where you want to handle the problem. The catch keyword indicates the catching of an exception.
try: A try block identifies a block of code for which particular exceptions will be activated. It's followed by one or more catch blocks.

Detecting a Exception (Try Block)

When a function might cause an exception, and therefore includes a statement that throws an exception, the call to the potentially offending function should be placed within a try block. A try block consists of one or more statements that the program attempts to execute, but which might result in thrown exceptions.
For Example:
int main() { int value; try { value = getUserNumber(); } cout << "Data entry value is " << value << endl; // rest of the program goes here } P.S. this program is incomplete you can't use try block without catch block.

Note : 1. try block consists of one or more statements that are guaranteed to throw exceptions when executed.
2. You want to place a function call in a try block when the function might throw an exception, because placing it in a try block allows you to handle the problem that caused the exception.
3. When a try block contains just one statement, you still must enclose the statement in curly braces.

Throwing Exception

Exceptions can be thrown anywhere within a code block using throw statements. The operand of the throw statements determines a type for the exception and can be any expression and the type of the result of the expression determines the type of exception thrown.

Following is an example of throwing an exception when dividing by zero condition occurs:
double division(int a, int b) { if( b == 0 ) { throw "Division by zero condition!"; } return (a/b); }

Catching Exception

To handle a thrown object, you include one or more catch blocks in your program immediately following a try block. A catch block contains statements that execute when an exception is thrown and includes the following components:
* the keyword catch
* a single parameter in parentheses
* an opening curly brace
* one or more statements that describe the exception action to be taken
* a closing curly brace
For Example
try { // protected code }catch( ExceptionName e ) { // code to handle ExceptionName exception }
Above code will catch an exception of ExceptionName type. If you want to specify that a catch block should handle any type of exception that is thrown in a try block, you must put an ellipsis, ..., between the parentheses enclosing the exception declaration as follows:
try { // protected code }catch(...) { // code to handle any exception }
The following is an example, which throws a division by zero exception and we catch it in catch block.
#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 << z << endl; }catch (const char* msg) { cerr << msg << endl; } return 0; }
Because we are raising an exception of type const char*, so while catching this exception, we have to use const char* in catch block. If we compile and run above code, this would produce the following result:
Division by zero condition!