Chapter 17: Advanced C++ Topics II

Chapter Goals

• To be able to implement templates
• To become familiar with exception handling

Templates

• A class template is a mechanism that allows us to create classes whose data fields have arbitrary type.
• We have already seen an example: the vector template.

  vector<int> v_i; 
  vector<double> v_d;
  vector<Employee> v_e;

• To define a template, denote the arbitrary type with a type parameter as show in syntax 17.3, and add the line template<typename T> before the class definition.

  template<typename T>
  class Pair {
  public:
     Pair(T a, T b);
     T get_first() const;
     T get_second() const;
  private:
     T first;
     T second;
  };

Syntax 17.3 Template Class Definition

template<typename type_variable>
class class_name
{
   features
};

template<typename T>
class Pair
{
public:
   Pair(T a, T b);
   T get_first() const;
   T get_second() const;
private:
   T first;
   T second;
};

• When you implement each member function, you must make it a template as indicated in syntax 17.4.

  template<typename T>
  Pair<T>::Pair(T a, T b)
  {  first = a;
     second = b;
  }
  
  template<typename T>
  T Pair<T>::get_first() const
  {  return first;
  }
  
  template<typename T>
  T Pair<T>::get_second() const
  {  return second;
  }

• Each function is turned into a separate template.
• Each function name is prefixed by the "Pair<T>::" qualifier.
• Note the use of the type variable T to represent a type.

Syntax 17.4 Template Member Function Definition

template<typename type_variable>
return_type class_name<type_variable>::function_name(parameters) constopt
{
   statements
}

template<typename T>
T Pair<T>::get_first() const
{
   return first;
}

Templates (pairs.cpp)

Exception Handling

Signaling Error Conditions

• How do you handle programmer errors when using a function or class?
  • 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 and alert the caller if it occurs.

    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 mechanism called exception handling. When a function detects an error, it can signal (throw an exception) a condition to some other part of the program whose job it 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);
  }

Syntax 17.8: Throwing an Exception

throw expression;

throw logic_error("illegal future_value parameter");

• Here, logic_error is a standard exception class that is declared in the <stdexcept> header.
• 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
  }

Syntax 17.9: Try Block

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";
}

• 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.

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 button, 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.

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

• A function signature can optionally be followed by the keyword throw and a parenthesized, comma-separated list of exception types; for example:
• 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.

Syntax 17.10: Exception Specification

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

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