Chapter 17: Advanced C++ Topics II

Lecture 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 (type-variable T), 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;
  };    

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.

  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.

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)

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

class List {
public:
   List();
   void push_back(string s);
   void insert(Iterator pos, string s);
   Iterator erase(Iterator pos);
   Iterator begin();
   Iterator end();
private:
   Node* first;
   Node* 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;
     ...
  };

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

class List
{
   ...
   class Iterator
   {
      ...
   };
};

• 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