13.3. Template Classes

Just as a template implementation only benefits select functions, a template implementation only benefits select classes. Data structures, called containers in C++ programs, are a prime example. "A data structure is a specialized format for organizing, processing, retrieving, and storing data. There are several basic and advanced types of data structures, all designed to arrange data to suit a specific purpose." Initially, C++ formed containers with multiple inheritance, inheriting "knowledge" of the container from one superclass and "knowledge" of the data from a second superclass. Today, it implements containers as classes with one or more template variables that specify the type of the contained data.

Some data structures or containers are simple enough for compilers to implement them directly in computer programming languages. For example, most languages support arrays, data files, structures, and classes as language primatives. Other data structures, such as stacks, lists, trees, and hash tables, are too complex to be language primitives. Nevertheless, these complex data structures are too useful to ignore, so programming languages typically provide them as classes organized into language libraries. Although the list of helpful data structures is long and varied, they all utilize the same basic template syntax.

Making And Using Template Classes

A stack is a classic data structure that is simple, yet complex enough to demonstrate template-based containers authentically. The text introduced stacks in detail in the arrays chapter and used them in subsequent examples, the most recent and relevant as a stack class demonstrating the this pointer. Basing a stack on templates is a simple upgrade that allows it to hold or contain any program-specified data type. The following figure illustrates the fundamental syntax and features of a template class.

#include <iostream>
using namespace std;

template <class T>
class stack
{
    private:
        static const int SIZE = 100;

        T    st[SIZE];
        int  sp = 0;

    public:
        void push(T data);
        T    pop();
        int  size();
        T    peek();
};

template <class T>
void stack<T>::push(T data)
{
    if (sp < SIZE)
        st[sp++] = data;
    else
        throw "Stack Overflow";
}


template <class T>
T stack<T>::pop()
{
    if (sp > 0)
        return st[--sp];
    else
        throw "Stack Underflow";
}

template <class T>
int stack<T>::size()
{
    return sp;
}


template <class T>
T stack<T>::peek()
{
    return st[sp - 1];
}

#include  <iostream>
#include  "stack.h"
using  namespace  std;

int main()
{
	stack<int>  s;

	s.push(10);
	s.push(20);
	s.push(30);

	cout << s.pop() << endl;
	cout << s.pop() << endl;
	cout << s.pop() << endl;

	return 0;
}
 
 
 
 

#include <iostream>
#include "Person.h"
#include "stack.h"
using  namespace  std;

int main()
{
	stack<Person>	p;
	Person		x("Alice");
	Person		y("Dilbert");
	Person		z("Wally");

	p.push(x);
	p.push(y);
	p.push(z);

	p.pop().display();
	p.pop().display();
	p.pop().display();

	return 0;
}

Template Constant-Value Expressions

Generalizing a stack by making it a template class greatly increases its utility. However, it still suffers from a significant weakness: specifying the stack size using the SIZE constant makes it inflexible. Specifically, it wastes space when only a small stack is needed and fails when a larger one is needed. Chapter 6 demonstrated that functions can specify default values for their arguments, and that programs accept or override those values. Templates provide programmers with the same flexibility when creating template classes. This approach requires modifying the template application code that specifies the container.

#include <iostream>
using namespace std;

template <class T, int SIZE = 100>
class stack
{
    private:
        T    st[SIZE];
        int  sp = 0;

    public:
        void push(T data);
        T    pop();
        int  size();
        T    peek();
};

template <class T, int SIZE>
void stack<T, SIZE>::push(T data)
{
    if (sp < SIZE)
        st[sp++] = data;
    else
        throw "Stack Overflow";
}

template <class T, int SIZE>
T stack<T, SIZE>::pop()
{
    if (sp > 0)
        return st[--sp];
    else
        throw "Stack Underflow";
}

template <class T, int SIZE>
int stack<T, SIZE>::size()
{
    return sp;
}

template <class T, int SIZE>
T stack<T, SIZE>::peek()
{
    return st[sp - 1];
}

#include  <iostream>
#include  "stack.h"
using  namespace  std;

int main()
{
	stack<int, 10>	s;
	stack<double>	d;

	s.push(10);
	s.push(20);
	d.push(2.7);
	d.push(3.1459);

	cout << s.pop() << endl;
	cout << s.pop() << endl;
	cout << d.pop() << endl;
	cout << d.pop() << endl;

	return 0;
}