Software Design Using C++

Introduction to the STL

What is the STL?

Some practical matters need to be mentioned here. To use the STL, you need to include the appropriate header and use the std namespace. If you wish to use some of the algorithms, then you must also include the algorithm header. The various function and class names of the STL are located in the std namespace so as to avoid conflicts with names that the programmer might create. Since it is a nuisance to have to write something like std::vector, one typically puts a using namespace std; line at the top of one's code file. This allows you to just refer to vector instead of std::vector, and so on. However, the disadvantage of this approach is that you may run into name conflicts.

Templates

The first two examples below use such template functions. In the first one, an array of integers is sorted and printed, whereas in the second one, an array of objects is sorted and printed. The template functions for sorting, swapping, and printing are exactly the same in these two programs. Based on how each of these functions is called, the compiler creates the appropriate specialization, or instance of the function. Even in the same program, one could call the BubbleSort template function twice, once to sort an array of ints and once to sort an array of floats. The compiler would include the two needed specializations of the generic BubbleSort routine. The important thing is that the programmer only has to write the code for sorting once.

Template Examples

template <class T> void PrintArray(T DataArray[], int Count)

In the code for the Swap function, you see that the parameters are reference parameters of type T. Also, there is a local variable of type T.

template <class T> void Swap(T & First, T & Second)
   {
   T Temp;

The template <class T> in front of the function name indicates that this function uses a generic type named T. (You can, of course, name it something other than T.) Note that the PrintArray function uses the << operator to write data of type T to an output stream. Therefore, this operator must be available for whatever data type we use in our program. Similarly, the Swap function assumes that assignment works for data of type T, while the BubbleSort function assumes that the > operator works.

In the first example program, these assumptions are not a problem since the program uses an array of ints, and these operators all work for ints. In the second program, which uses an array of objects, the class has to be set up to provide overloaded operators that work with objects of the class. That is a bit of a nuisance, but once this is done, the exact same BubbleSort and PrintArray functions work. Having generic array-sorting and array-printing functions is very helpful. They make code reuse so much more practical!

The third example above shows how to set up a template class (also called a generic class). This program has a template-based class called ArrStackClass that provides an array implementation of stacks. The nice feature about the generic class is that it can be used to provide a stack of integers and a stack of characters, with no change to the class or its functions. This particular example creates one stack of each, both in the same program.

The template <class T> in front of the class declaration indicates that this class uses a generic type named T. Note that an object of this class contains a private data field, Info, which is an array of items of type T. Note the way that the prototypes for the class functions are written. For example, here is the one for Pop:

template <class T> void ArrStackClass<T>::Pop(T & Item)

Then, when you go to create an object belonging to this class, you need to specify what type gets used for T. For example, to create a stack S of integers you would use something like this:

ArrStackClass<int> S;

Optional Template Examples

template <class TypeA, class TypeB> void Output2(TypeA First, TypeB Second)
   {
   cout << First << "  " << Second << endl;
   }

In templat5.cpp a template class is set up that is parameterized by two types. This template class is named OrderedPair since objects of this class are ordered pairs of values, where the two values in a given pair do not have to be of the same type. The test program sets up and prints various ordered pairs. The class declaration itself is shown below. Follow the link to the example for the function definitions.

template <class TypeA, class TypeB> class OrderedPair
   {
   private:
      TypeA First;
      TypeB Second;
   public:
      OrderedPair(TypeA InitFirst, TypeB InitSecond);
      void SetFirst(TypeA NewFirst);
      void SetSecond(TypeB NewSecond);
      void GetFirst(TypeA & FirstValue) const;
      void GetSecond(TypeB & SecondValue) const;
      void Print(void) const;
   };

Finally, the optional example templat6.cpp contains a template function that displays the maximum of a pair of values. Both items in the pair must be of the same generic type T. The function returns the maximum in the function name, just to show that this can be done. An alternate way, of course, would be to return the maximum in a reference parameter. Here is the function definition:

template <class T> T Maximum(T First, T Second)
   {
   if (First > Second)
      return First;
   else
      return Second;
   }