Advanced C++ Topics

Chapter 17: Advanced C++ Topics II

Chapter Goals

To be able to implement templates
To understand nested classes
To define and use name spaces
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 (next slide), 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;
};
```

Templates (Syntax 17.3 Template Class Definition)

Syntax 17.3 : Template Class Definition

template<typename type_variable>
class class_name
{
   features
};

Example:	template<typename T> class Pair { public: Pair(T a, T b); T get_first() const; T get_second() const; private: T first; T second; };
Purpose:	Define a class template with a type parameter.

Templates

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

Syntax 17.4 : Template Member Function Definition

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

Example:	template<typename T> T Pair<T>::get_first() const { return first; }
Purpose:	Supply the implementation of a member function for a class template.

Templates

A template version of the List class presented in chapter 16 follows.

template<typename T>
class List {
public:
   List();
   void push_back(T s);
   void insert(Iterator<T> pos, T s);
   void erase(Iterator<T> pos);
   Iterator<T> begin();
   Iterator<T> end();
private:
   Node<T>* first;
   Node<T>* last;
}

Both the Node and Iterator classes need to be made templates as well.

Each member function must also be made into a template.

template<typename T>
Iterator<T> List<T>::begin()
{  Iterator<T> iter;
   iter.position = first;
   iter.position = last;
   return iter;
}

Templates (`list.cpp`)

Nested Classes and Name Spaces

In the standard library, the iterator class is nested inside the list class.
```
list<string>::iterator pos = staff.begin();
```
The reason is so several different implementations (for vectors, lists, maps, and sets) can all share the same name (iterator), but have different implementations.
```
vector<double>::iterator p = a.begin();
list<string>::iterator q = b.begin();
```
To nest a class inside another, first declare the nested class inside the outer class.
```
class List {
   ...
   class Iterator;
   ...
};
```

Syntax 17.5 : Nested Class Declaration

class Outer_class_name
{
   ...
   class Nested_class_name
   {
      ...
   };
   ...
}

Example:	class List { ... class Iterator { ... }; };
Purpose:	Define a class whose scope is contained in the scope of another class.

Nested Classes and Name Spaces

The definition of the member functions requires references to both the outer and inner classes.
```
List::Iterator::Iterator()
{
   ...
}

string List::Iterator::get() const
{
   ...
}
```
Note that the name of constructor is just Iterator.
In general, use nested classes for just one reason: to place the name of a class inside the scope of another class.

Nested Classes and Name Spaces

Name spaces are also used to avoid naming conflicts.
By using name spaces, it becomes possible to use classes or functions with the same name in the same program.
```
std::map /* standard library template map */
acme::map /* another class called map */
```
To add classes, functions, or variables to a name space, surround their declarations with a namespace block.
```
namespace acme
{
   class map
   {
      ...
   };
 
   void draw(map m);
}
```
Namespaces are open - you can add as many items to a namespace as you like by starting another namespace block.
```
namespace acme
{
   class maze
   {
      ...
   }
};
```

Syntax 17.6 : Name Space Definition

namespace name_space_name
{
   feature₁
   feature2
   ...
   featuren
};

Example:	namespace ACME_Software_San_Jose_CA_US { class map { ... }; }
Purpose:	Include a class, function or variable in a name space.

Nested Classes and Name Spaces

Instead of using a prefix qualifier, if there are no conflicts we can just start a program with a using declaration.
This allows us to use cout instead of std::cout.
Since you create name spaces to avoid name clashes, you want to name them in a unambiguous (usually long) way, such as ACME_Software_San_Jose_CA_US.
Unfortunately, it would be painful to constantly type
```
ACME_Software_San_Jose_CA_US::map
```
You can define a short alias for a long name space.
```
namespace acme = ACME_Software_San_Jose_CA_US
```

Syntax 17.7 : Name Space Alias

namespace alias_name = name_space_name;

Example:	namespace acme = ACME_Software_San_Jose_CA_US;
Purpose:	Introduce a short alias for the long name of a name space.

Exception Handling

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

Syntax 17.8 : Throwing an Exception

throw expression;

Example:	throw logic_error("illegal future_value parameter");
Purpose:	Abandon this function and throw a value to an exception handler.

Exception Handling

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.
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_name₁ variable_name₁)
{
   statements
}
catch (type_name2 variable_name2)
{
   statements
}
...
catch (type_namen variable_namen)
{
   statements
}

Example:	try { List staff = read_list(); process_list(staff); } catch(logic_error& e) { cout << "Processing error " << e.what() << "\n"; }
Purpose:	Provide one or more handlers for types of exceptions that may be thrown when executing a block of statements.

Exception Handling

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 locic_error class returns the string that was passed to the constructor of the error object in the throw statement.

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

BecauseFutureValueError 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)
{
   handler₁
} 
catch (logic_error& e)
{
   handler₂
}
```

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

Exception Handling

Consider the following function:

void process_products(fstream& fs)
{  list<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 list 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.

The best remedy is to make sure that all allocated memory is deleted in a destructor.

If a local pointer variable i 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.

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_name₁, type_name₂, ..., type_name_n)

Example:	void process_products(fstrream& fs) throw(UnexpectedEndOfFile, bad_alloc)
Purpose:	List the types of all exceptions that a function can throw.

Chapter 17: Advanced C++ Topics II

Chapter Goals

Templates

Templates (Syntax 17.3 Template Class Definition)

Templates

Syntax 17.4 Template Member Function Definition

Templates

Templates (list.cpp)

Nested Classes and Name Spaces

Syntax 17.5 : Nested Class Declaration

Nested Classes and Name Spaces

Nested Classes and Name Spaces

Syntax 17.6 : Name Space Definition

Nested Classes and Name Spaces

Syntax 17.7 : Name Space Alias

Exception Handling

Syntax 17.8 : Throwing an Exception

Exception Handling

Syntax 17.9 : Try Block

Exception Handling

Exception Handling

Syntax 17.10 : Exception Specification

Templates (`list.cpp`)