Root: 1 revision(s)

2007-06-08T15:04:46Z

1 revision(s)

← Older revision	Revision as of 15:04, 8 June 2007
(No difference)

Root at 09:46, 3 April 2007

2007-04-03T09:46:44Z

New page

=Exceptions=

Exceptions provide a way to react to exceptional circumstances (like runtime errors) in our program by transferring control to special functions called ''handlers''.

To catch exceptions we must place a portion of code under exception inspection. This is done by enclosing that portion of code in a ''try block''. When an exceptional circumstance arises within that block, an exception is thrown that transfers the control to the exception handler. If no exception is thrown, the code continues normally and all handlers are ignored.

A exception is thrown by using the throw keyword from inside the try block. Exception handlers are declared with the keyword catch, which must be placed immediately after the try block:

{| class="codebox"
| class="code" |
// exceptions
<nowiki>#include <iostream></nowiki>
using namespace std;

int main () {
try
{
throw 20;
}
catch (int e)
{
cout << "An exception occurred. Exception Nr. " << e << endl;
}
return 0;
}

| class="result" |
An exception occurred. Exception Nr. 20
|}

The code under exception handling is enclosed in a <tt>try</tt> block. In this example this code simply throws an exception:

{| class="snippet"
| class="code" |
throw 20;
|}

A throw expression accepts one parameter (in this case the integer value <tt>20</tt>), which is passed as an argument to the exception handler.

The exception handler is declared with the <tt>catch</tt> keyword. As you can see, it follows immediately the closing brace of the <tt>try</tt> block. The catch format is similar to a regular function that always has at least one parameter. The type of this parameter is very important, since the type of the argument passed by the throw expression is checked against it, and only in the case they match, the exception is catch.

We can chain multiple handlers (catch expressions), each one with a different parameter type. Only the handler that matches its type with the argument specified in the throw statement is executed.

If we use an ellipsis (<tt>...</tt>) as the parameter of <tt>catch</tt>, that handler will catch any exception no matter what the type of the <tt>throw</tt> exception is. This can be used as a default handler that catches all exceptions not caught by other handlers if it is specified at last:

{| class="snippet"
| class="code" |
try {
// code here

}
catch (int param) { cout << "int exception"<nowiki>; }
</nowiki>catch (char param) { cout << "char exception"<nowiki>; }

</nowiki>catch (...) { cout << "default exception"<nowiki>; }
</nowiki>
|}

In this case the last handler would catch any exception thrown with any parameter that is neither an <tt>int</tt> nor a <tt>char</tt>.

After an exception has been handled the program execution resumes after the <tt>try-catch</tt> block, not after the <tt>throw</tt> statement!.

It is also possible to nest <tt>try-catch</tt> blocks within more external <tt>try</tt> blocks. In these cases, we have the possibility that an internal <tt>catch</tt> block forwards the exception to its external level. This is done with the expression <tt>throw;</tt> with no arguments. For example:

{| class="snippet"
| class="code" |
try {
try {
// code here

}
catch (int n) {
throw<nowiki>;
}
}
</nowiki>catch (...) {
cout << "Exception occurred"<nowiki>;
}
</nowiki>
|}

===Exception specifications===

When declaring a function we can limit the exception type it might directly or indirectly throw by appending a <tt>throw</tt> suffix to the function declaration:

{| class="snippet"
| class="code" |
float myfunction (char param) throw (int);

|}

This declares a function called <tt>myfunction</tt> which takes one agument of type <tt>char</tt> and returns an element of type <tt>float</tt>. The only exception that this function might throw is an exception of type <tt>int</tt>. If it throws an exception with a different type, either directly or indirectly, it cannot be caught by a regular <tt>int</tt>-type handler.

If this <tt>throw</tt> specifier is left empty with no type, this means the function is not allowed to throw exceptions. Functions with no <tt>throw</tt> specifier (regular functions) are allowed to throw exceptions with any type:

{| class="snippet"
| class="code" |
int myfunction (int param) throw(); // no exceptions allowed

int myfunction (int param); // all exceptions allowed
|}

===Standard exceptions===

The C++ Standard library provides a base class specifically designed to declare objects to be thrown as exceptions. It is called <tt>exception</tt> and is defined in the <tt><exception></tt> header file under the <tt>namespace std</tt>. This class has the usual default and copy constructors, operators and destructors, plus an additional virtual member function called <tt>what</tt> that returns a null-terminated character sequence (<tt>char *</tt>) and that can be overwritten in derived classes to contain some sort of description of the exception.

{| class="codebox"
| class="code" |
// standard exceptions

<nowiki>#include <iostream></nowiki>
<nowiki>#include <exception></nowiki>
using namespace std;

class myexception: public exception
{
virtual const char<nowiki>* what() </nowiki>const throw()
{
return "My exception happened"<nowiki>;
}
} myex;

</nowiki>int main () {
try
{
throw myex;
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}

| class="result" |
My exception happened.
|}

We have placed a handler that catches exception objects by reference (notice the ampersand <tt>&</tt> after the type), therefore this catches also classes derived from <tt>exception</tt>, like our <tt>myex</tt> object of class <tt>myexception</tt>.

All exceptions thrown by components of the C++ Standard library throw exceptions derived from this <tt>std::exception</tt> class. These are:

{| class="boxed"
! exception
! description
|-
| bad_alloc
| thrown by new on allocation failure
|-
| bad_cast
| thrown by dynamic_cast when fails with a referenced type
|-
| bad_exception
| thrown when an exception type doesn't match any catch
|-
| bad_typeid
| thrown by typeid
|-
| ios_base::failure
| thrown by functions in the iostream library
|}

For example, if we use the operator <tt>new</tt> without <tt>(nothrow)</tt> and the memory cannot be allocated, an exception of type <tt>bad_alloc</tt> is thrown:

{| class="snippet"
| class="code" |
try

{
int * myarray= new int[1000];
}
catch (bad_alloc&)
{
cout << "Error allocating memory." << endl;
}

|}

It is recommended to include all dynamic memory allocations within a try block that catches this type of exception to perform a clean action instead of an abnormal program termination, which is what happens when this type of exception is thrown and not caught. If you want to force a <tt>bad_alloc</tt> exception to see it in action, you can try to allocate a huge array; On my system, trying to allocate 1 billion <tt>int</tt>s threw a <tt>bad_alloc</tt> exception.

Because <tt>bad_alloc</tt> is derived from the standard base class <tt>exception</tt>, we can handle that same exception by catching references to the <tt>exception</tt> class:

{| class="codebox"
| class="code" |
// bad_alloc standard exception

<nowiki>#include <iostream></nowiki>
<nowiki>#include <exception></nowiki>
using namespace std;

int main () {
try
{
int<nowiki>* myarray= </nowiki>new int[1000];
}
catch (exception& e)
{
cout << "Standard exception: " << e.what() << endl;
}
return 0;
}
|}

Template:Cpptutorial Exceptions - Revision history

Root: 1 revision(s)

Root at 09:46, 3 April 2007