Advanced C++ Topics

Chapter 17: Advanced C++ Topics II

Chapter Goals

To be able to implement templates and nested classes

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

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.

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) 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 (`pairs.cpp`)

A template version of the List class presented in chapter 16 (list2.cpp) 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

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.

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.
Example: list1.cpp