Lecture Notes for Advanced Programming II

12 February 2004 - Exception Examples

Error Handling With Instance Variables

class node {
  public:
    enum status {
      ok,
      error
      };

    status error_code;

    node() { 

      if (no error)
        error_code = ok;
      else
	error_code = error;
      }
  };

• Could also use an access function to return error_code.

• This code assumes construction always succedes.

  • If it didn't, error_code wouldn't exist.

• If error_code was static, the constructor could completely bomb out.

Using Error Instance Variables

#include <node.h>

int main() {

  // No error checking.

     node n1;
  
  // Do some error checking.

     node n2;
     if (n2.error_code != node::ok) {
       // handle error.
       }
  }

• Both n1 and n2 must be constructed, always.

Error Handling With Parameters

• Need to worry about the default constructor.

  class node {
  
    public:
  
      enum status {
        ok,
        error
        };
  
      node(status & s = st) { 
        if (no error)
          s = ok;
        else
  	s = error;
        }
  
    private:
      static status st;
    };
  

• No default constructor without the default parameter value.

• Pointers work too, but it's messier.

• static is necessary; the compiler needs to know the default value.

Using Error Parameters

#include <node.h>

int main() {

  // No error checking.

     node n1;
  
  // Do some error checking.

     node::status s;
     node n2(s);
     if (s != node::ok) {
       // handle error.
       }
  }

Error Handling With Exceptions

• The constructor throws an exception.

  #include <exception>
  
  class node {
  
    public:
  
      struct node_exception : public exception {
        const char * emsg;
        node_exception(const char * s) : emsg(s) { }
        const char * what(void) const { return emsg; }
        };
  
  
      node() { 
  
        // Here's an error.
  	 
           throw node_exception("some terrible error");
        }
    };
  

• What's with all those character arrays?

  • exception::what() requires them.

  • They're constants.

Using Exception Errors

#include "node.h"
#include <iostream>
#include <cstdlib>

int main() {

  try {
    node n;
    }
  catch (node::node_exception ne) {
    cerr << "Error during node create:  "
         << ne.what() << ".\n";
    exit(EXIT_FAILURE);
    }
  }

• There isn't an option to not handle the exception.

  • Something, somewhere is going to deal with it.

• The class instance n is unambiguously good or bad.

• All code using n has to be in the try block.

Error Handling With Functions

• The constructor caller passes in an error-handling function.

  • Don't forget the default constructor problem.

  class node {
  
    public:
  
      node(void (* efun)(const char *) = df) { 
  
        if (some terrible error)
          efun("some terrible error");
        }
  
    private:
  
      static void df(const char *);
    };
  

• UI programmers will recognize this as a callback function.

Using Error Functions

#include "node.h"
#include <iostream>
#include <cstdlib>

static void efun(const char * emsg) {
  cerr << "Error during node create:  "
       << emsg << ".\n";
  exit(EXIT_FAILURE);
  }

int main() {

  node n1;
  node n2(efun);

  }

Which is Better?

• It's a toss-up for code clarity.

  • Variables then parameters have slightly smaller code.

  • Functions provide better structure.

  • Fine-grain try statements are ugly.

• Exceptions handle errors in node arrays better.

  • Variables can be made sticky.

  • Non-default parameters and functions lose.

• Variables and parameters are better for ignoring errors.

  • Once raised, an exception has to be handled.

  • Once called, the function executes.

• Functions can be obscure.

  • Variables and parameters are easy to understand.

  • Functions may be difficult (globals access).

  • Exceptions are very difficult (dynamic behavior).

This page last modified on 10 February 2004.