The first thing we need to do is decide what type of exceptions we are going to handle and describe them as classes. In our stack example, the only exception we expect is an out-of-bounds error. We’ll describe this error with a simple string. The class for an out-of-bounds error is:

class bound_err {
    public:
        const string what;     // What caused the error

        // Initialize the bound error with a message
        bound_err(const std::string& i_what): what(i_what) {}
        // bound_err&  operator = -- defaults 
        // bound_err(bound_err) -- default copy constructor
        // ~bound_err -- default destructor
};

Exception checking starts with the keyword try . This tells C++ that exceptions may be generated in the section of code that follows and that they will be handled immediately after the try block. For example, if we are trying to perform a big stack operation, the code might look like this:

try {
    do_big_stack_operation(  );
};

Immediately after the try block, we need to use a catch statement to tell C++ what problems we will handle. The syntax for this statement is:

catch (problem_type& parameter) { 
    statements;
}

The problem_type is the class that describes what happened. For the out-of-bounds error, the catch statement looks like:

catch (bound_err& what_happened) { 
    std::cerr << "Error: Bounds exceeded
";
    std::cerr << "Reason: " << what_happened.what << '
';
}

Several catch statements may be used to catch different types of exceptions. If an exception is not caught, it is considered an unexpected exception and will cause a call to the unexpected-exception handler, which aborts the program by default. If you want to catch all exceptions, use “...” for the exception type. For example:

catch (bound_err& what_happened) { 
    // .... Body of catch
}
catch (...) {
    std::cerr << "Something strange happened
";
}

Now we need to update our old stack program and replace all the “error-message-and-abort” code with throw statements. The new procedure for push now looks like this:

inline void stack::push(const int item)
{
    if ((count < 0) ||
        (count >= sizeof(data)/sizeof(data[0]))) {
        bound_err overflow("Push overflows stack");
        throw overflow;
    }
    data[count] = item;
    ++count;
}

Actually we don’t need a special variable for overflow. The code can be consolidated. In the previous example, I used two statements to show explicitly what is going on. The following code performs the same operation:

inline void stack::push(const int item)
{
    if ((count < 0) ||
        (count >= sizeof(data)/sizeof(data[0]))) {
        throw bound_err("Push overflows stack");
    }
    data[count] = item;
    ++count;
}

The basic function definition we’ve been using so far tells C++, “Expect any exception to be thrown at any time.” The push function can only throw a bound_err exception. C++ allows you to list all the possible exceptions in a function by putting a throw directive at the end of the function declaration:

inline void stack::push(const int item) throw(bound_err) {

But what happens if we throw an exception that’s not in the list of exceptions? C++ turns this into a call to the function unexpected( ). This normally causes the program to terminate.

Example 22-1 contains a stack that uses exceptions when something goes wrong.

/********************************************************
 * Stack                                                *
 *      A file implementing a simple stack class        *
 ********************************************************/
#include <cstdlib>
#include <iostream>
#include <cassert>

const int STACK_SIZE = 100;     // Maximum size of a stack

/********************************************************
 * bound_err -- a class used to handle out of bounds    *
 *              execeptions.                            *
 ********************************************************/
class bound_err {
    public:
        const string what;      // What caused the error

        // Initialize the bound error with a message
        bound_err(const string& i_what) what(i_what) {}
        // Assignment operator defaults
        // bound_err(bound_err) -- default copy constructor
        // ~ bound_err -- default destructor
};

/********************************************************
 * Stack class                                          *
 *                                                      *
 * Member functions                                     *
 *      init -- initialize the stack.                   *
 *      push -- put an item on the stack.               *
 *      pop -- remove an item from the stack.           *
 ********************************************************/
// The stack itself
class stack {
    private:
        int count;              // Number of items in the stack
        int data[STACK_SIZE];   // The items themselves
    public:
        // Initialize the stack
        stack(  ): count(0) {};
        // Copy constructor defaults
        // Assignment operator defaults

        // Push an item on the stack
        void push(const int item) throw(bound_err);

        // Pop an item from the stack
        int pop(  ) throw(bound_err);
};
/********************************************************
 * stack::push -- push an item on the stack.            *
 *                                                      *
 * Warning: We do not check for overflow.               *
 *                                                      *
 * Parameters                                           *
 *      item -- item to put in the stack                *
 ********************************************************/
inline void stack::push(const int item) throw(bound_err)
{
    if ((count < 0) ||
           (count >= sizeof(data)/sizeof(data[0]))) {
        throw("Push overflows stack");
    }
    data[count] = item;
    ++count;
}
/********************************************************
 * stack::pop -- get an item off the stack.             *
 *                                                      *
 * Warning: We do not check for stack underflow.        *
 *                                                      *
 * Returns                                              *
 *      The top item from the stack.                    *
 ********************************************************/
inline int stack::pop(  ) throw(bound_err)
{
    // Stack goes down by one
    --count;

    if ((count < 0) ||
           (count >= sizeof(data)/sizeof(data[0]))) {
        throw("Pop underflows stack");
    }
    // Then we return the top value
    return (data[count]);
}
static stack test_stack;        // Define a stack for our bounds checking

/********************************************************
 * push_a_lot -- Push too much on to the stack          *
 ********************************************************/
static void push_a_lot(  ) {
   int i;       // Push counter

    for (i = 0; i < 5000; i++) {
        test_stack.push(i);
    }
}

int main(  )
{
    try {
       push_a_lot(  );
    }
    catch (bound_err& err) {
       cerr << "Error: Bounds exceeded
";
       cerr << "Reason: " << err.what << '
';
       exit (8);
    }
    catch (...) {
       cerr << "Error: Unexpected exception occurred
";
       exit (8);
    }
    return (0);
}

Let’s say we want to make sure that the stack is empty when it’s destroyed. So we write a destructor for our stack class:

// This is not a good idea
inline stack::~stack(  ) {
    if (count != 0)
        throw(bound_err("Stack is not empty"));
}

This sort of code contains a hidden trap waiting to be sprung. Let’s suppose that we push a few items on the stack and then execute some unrelated code that causes an exception to be thrown. The sequence of events is:

So what happens when an exception is thrown inside an exception? The answer is that the program terminates, so it’s not a good idea to throw an exception in a destructor.