Chapter 17: Advanced C++ Topics III

Lecture Goals

• To become familiar with exception handling

Exception Handling

Signaling Error Conditions

• How do you handle programmer errors when using a function or class?
• For example:

  cout << future_value(1000, -100, -1);

• Don't check the error condition and executing the code anyway, possibly causing a problem.

  double future_value(double initial_balance, double p, int n)
  {  return initial_balance * pow(1 + p / 100, n);
  }

• Check the error condition and doing nothing if it occurs.

  double future_value(double initial_balance, double p, int n)
  {  if (p < 0 || n < 0) return 0;
     return initial_balance * pow(1 + p / 100, n);
  }

• Check the error condition, alert the caller if it occurs and stop execution.

  double future_value(double initial_balance, double p, int n)
  {  assert(p >= 0 && n >= 0);
     return initial_balance * pow(1 + p / 100, n);
  }

• Problems:
  • If you don't check for the error, your program may be unreliable.
  • If you return a fake value, the program continues using the value. No one knows what the error was, only that something went wrong.
  • Many real pieces of software can't be halted, such as one that controls a rocket or a medical device.
• C++ has a notification mechanism called exception handling. When a function detects an error, it can signal a condition (throw an exception) to some other part of the program whose job is to deal with errors.

  double future_value(double initial_balance, double p, int n)
  {  if (p < 0 || n < 0)
     {  logic_error description("illegal future_value parameter");
        throw description;
     }
     return initial_balance * pow(1 + p / 100, n);
  }

• Many programmers don't bother to give the exception object a name and just throw an anonymous object, like this:

  double future_value(double initial_balance, double p, int n)
  { if (p < 0 || n < 0)
      throw logic_error("illegal future_value parameter");
   return initial_balance * pow(1 + p / 100, n);
  }

• Here, logic_error is a standard exception class that is declared in the <stdexcept> header.

throw expression;

throw logic_error("illegal future_value parameter");

• The keyword throw indicates that the function exits immediately, but the function does not return to the caller. Instead, the program searches for a handler that specifies how to handle the logic error.

Catching Exceptions

• You supply an exception handler with the try statement.

  try
  {
     // code
  }
  catch (logic_error& e)
  {
     // handler
  }

• If any of the functions in the try clause throw a logic_error, or call another function that throws such an exception, then the code in the catch clause executes immediately.

  while (more)
  {  try 
     {
        // code
     }
     catch (logic_error& e)
     {  cout << "A logic error has occurred "
             << e.what() << "\n" << "Retry? (y/n)";
        string input;
        getline(cin, input);
        if (input == "n") more = false;
     }
  }

• The what member function of the logic_error class returns the string that was passed to the constructor of the error object in the throw statement.

try
{
 statements 
}
catch (type_name1 variable_name1)
{
 statements
}
catch (type_name2 variable_name2)
{
 statements
}
...
catch (type_namen variable_namen)
{
 statements
}

try
{
 double fvalue = future_value(init, interest, years); 
 cout << "The future value is " << fvalue << endl;
}
catch(logic_error& e)
{
 cout << "Processing error " << e.what() << "\n";
}

Exception Handling (exception1.cpp)

• It's a good idea to use inheritance to define your own exception types.

  class FutureValueError : public logic_error {
  public:
     FutureValueError(const char reason[]);
  };
  
  FutureValueError::FutureValueError(const char reason[])
     : logic_error(reason){}

• Here, the future_value function can now throw a FutureValueError object.

  if (p < 0 || n < 0)
     throw FutureValueError("illegal parameter");

• Because FutureValueError is a logic_error, you can still catch it with catch(logic_error& e).
• You can even catch other types of errors. Note that the exception handling mechanism matches the handlers top to bottom, and executes the first matching handler.

  try
  {
     // code
  }
  catch (FutureValueError& e)
  {
     // handler1
  } 
  catch (logic_error& e)
  {
     // handler2
  }

Exception Handling (exception2.cpp)

Stack Unwinding

• One common use of exception handling is in functions that read input.
• Example: suppose that no price or score is given:

  bool Product::read(fstream& fs)
  {  getline(fs, name);
     if (name == "") return false; // end of file
     fs >> price >> score;
     if (fs.fail())
        throw runtime_error("Error while reading product");
     string remainder;
     getline(fs, remainder);
     return true;
  }

• When a logic error occurs, it never makes sense to retry the same operation, but a runtime error may have some chance of going away when the operation is attempted again.
• Note that this function distinguishes between the expected end of file (returning false), and an unexpected problem (which throws an exception).

• Here we see the hierarchy of standard exception types in C++.

• Consider the following function:

  void process_products(fstream& fs)
  {  vector<Product> products;
     bool more = true;
     while (more)
     {  Product p;
        if (p.read(fs)) products.push_back(p);
        else more = false;
     }
     // do something with products
  }

• If the read function throws an exception, the process_products functions halts, and the exception handling mechanism searches for an appropriate handler.
• The C++ exception handling mechanism invokes all destructors of stack objects before it abandons a function.
• In our example, the vector object is destroyed, along with all Products in the list.

• This automatic invocation of destructors only applies to objects.
• Consider the following code.

  Product* p = new Product();
  if (p->read())
  {
     ...
  }
  delete p; // never executes if read throws an exception

• If an exception occurs in the read function, p receives no special attention because it is not an object.
• A memory leak occurs.

Exception Handling (product1.cpp)

• The best remedy is to make sure that all allocated memory is deleted in a destructor.
• If a local pointer variable unavoidable, you can use the following construct:

  Product* p = NULL;
  try
  {  p = new Product();
     if (p->read())
     {
        ...
     }
     delete p;
  }
  catch(...)
  {  delete p;
     throw;
  }
  

• The clause catch(...) matches any exception.
• The handle contains the local cleanup, followed by the throw statement without an exception object.
• This rethrows the exception so that the correct handler can process it.

Exception Handling (product2.cpp)

Exception Specifications

• If an exception is thrown and no catch clause exists to catch it, then the program terminates with an error message.
• Because of potential dangers in throwing exceptions, a function can declare that it only throws exceptions of a certain type, or no exceptions at all.
• You can use that knowledge to make sure that it is safe to call certain functions, or to know which kinds of exceptions you program needs to catch.
• A function signature can optionally be followed by the keyword throw and a parenthesized, comma-separated list of exception types; for example:

  void process_products(fstream& fs)
   throw (UnexpectedEndOfFile, bad_alloc)

• To denote that a function throws no exceptions, use an empty exception list.

  void process_products(fstream& fs)
     throw ()

• A function without a throw specification is allowed to throw any exceptions.

return_type function_name(parameters)
   throw (type_name1, type_name2, ..., type_namen)

void process_products(fstream& fs)
   throw(UnexpectedEndOfFile, bad_alloc)

• Stroustrup's example: class Vector (strous.cpp)