CMPT 212 Object-Oriented Applications Design in C++ Fall 1997

Read section Exceptions of chapter 14 from C++ Primer Plus (2nd ed.), by Stephen Prata.

Exceptions

• Exceptions are a language feature that enables programs to handle errors and other abnormal situations in an elegant way.
  • Exceptions allow the programmer to separate the error-checking and error-handling code from the "regular" code.

• The exception mechanism in C++ is implemented by the keywords try, throw, and catch.
  • The try keyword indicates a block of code in which we expect exceptions to be generated.

  • The throw keyword indicates that we are generating an exceptions.

  • The catch keyword follws a try block and indicates what we should do if an exception is generated.

• Example:

     int i;
     ...
     try {
        if (i < 0) {
  	 throw "negative number";
  	 }
        else {
  	 cout << i << endl;
  	 }
        }
     catch (char * str) {
        cout << str << endl;
        }
  	 

• When we throw an exception, we specify the value of the exception.

• Each catch clause has a type associated with it. It will catch an exception of this type.
  • If an exception is thrown which does not match the type in any of our catch clauses, then the exception will be re-thrown so that it can be caught by an exception handler higher up on the call stack.

  • The clause catch (...) will catch any exception.

• Example:

     float square_root(float f) {
        if (f < 0) {
  	 throw "negative number";
  	 }
        else {
  	 return sqrt(f);
  	 }
     }
  
     void func() {
        float f;
        cin >> f;
        try {
  	 cout << square_root(f) << endl;
  	 }
        catch (char * str) {
  	 cout << str << endl;
  	 }
        catch (int i) {
  	 cout << i << endl;
  	 }
        catch (...) {
  	 cout << "unknown exception" << endl;
  	 }
     }
  	 

• When an exception is thrown, control passes to the nearest catch clause which catches an exception of this type.
  • If the catch clause is in some enclosing function, then the inner functions are exited.

  • If there is no such catch clause, the program is halted with an "uncaught exception" run-time error.

• In a function prototype, we can declare what types of exceptions the function may throw.
  • Example:

       float square_root(float) throw (char *);
       void other_func() throw (int, char *);
       void f() throw ();     // throws no execptions.
    	       

  • Note that if function f calls function g, and g throws an exception which f does not catch, then that exception is also thrown by f.

  • By declaring in the function prototype the types of exceptions thrown, we can see what exceptions may be thrown by functions that we are calling. We can then decide whether we want to catch them or let them be passed up to the function which called our function.

• An exception value can be an object.
  • Example:

       class myException {
          public:
    	 myException(int i) { ... }
    	 void display() { ... }
          ...
          }:
    
       void f() {
          try {
    	 ...
    	 throw myException(3);
    	 ...
    	 }
          catch (myException& e) {
    	 e.display();
    	 }
          ...
       }
    	       

• In a larger program, there may be a hierarchy of classes derived from some base execption class.
  • If we want to catch a specific type of exception, we specify that type in the catch clause:

       catch (derivedException& e) { ... }
    	       

  • We may have this hierarchy of exception classes:

Return to lecture notes index

Lectures