Exceptions

Exceptions provide an alternate pathway to exit a function/procedure, one that is taken when there is an error or issue that means the function cannot perform its actions as normal.

Exceptions — when, why, and how

You should avoid using exceptions as much as possible, but they are useful when you start building libraries or other components where you do not have full control of how the code works. In these cases you can use exceptions as a way of saying “I can’t do what you are asking…”.

For now, it is good to keep in mind that code you call may also throw exceptions.

In C/C++

Syntax

In C/C++ you can throw any type of data. The syntax is throw followed by the data to use as the exception.

To catch, you need a try block followed by one or more catch blocks. In each catch you can specify the type of exception to catch by declaring a variable to store the exception within the catch block’s parenthesis. You can also catch any exception using catch(...) { }.

Exceptions Up Close

The following images will step you through execution of the throw and catch mechanic.

Try is encountered

• Try block registers we have catch blocks
• The check variable is created in main

 

Normal Path

• Here we pass 5 to double_positive
• This will let us see the normal behaviour

 

Normal Path - no exception

• Value is not less than 0, so we skip the code that throws

 

Normal Path - value returned to caller

• We return 10 back to the caller - main

 

Normal Path - catch skipped

• When we get to the end of the try block, we skip the catch blocks.
• The catch statements are only executed if an exception is thrown
• This should be the case most of the time

 

Exception Path - calling with negative value

• When we get to the end of the try block, we skip the catch blocks.
• The catch statements are only executed if an exception is thrown

 

Exception Path - exception thrown

• Value is less than 0, so we throw the message
• Message is a string - not shown in the illustration

 

Exception Path - exception back up stack for catch

• The exception handling code takes over, and will search back up the stack for a handler
• double_positive ends, as there is no catch here

 

Exception Path - try is found in main

• Try is found in main - so the handler checks for a matching catch
• We threw a string, and there is a matching block
• Control will now continue within this catch block

 

Exception Path - catch takes over

• Space for e is allocated on the stack
• e is given the value thrown
• The code in the catch is run
• Other catch blocks will be skipped, if any exist
• Execution will continue as normal from here

 

Uncaught Exception Path - what if we throw an int in this case?

• If we change double_positive to throw an int
• There is no matching catch

 

Uncaught Exception Path - main ends as well

• As there is no catch block to use, the current function ends too
• This would continue to search further back in the stack, if there were more stack frames
• In this case, when main ends the program terminates
• The exception handler then outputs a message to help us understand what happened

 

Summary

Exceptions are a structured mechanism that provide an alternate exit path from a function or procedure, one that is faciliated by the exception handling code provided by the language. The exception handler will search back through the stack for the first matching catch block, and it will return execution to that point. Where no matching catch blocks are found, the exception will terminate the program.

Avoid using exceptions where you can, but these will come in handy when you start to build reusable utilities.