Cpp Chapter 14: Reusing code in C++ Part2

14.4 Class Templates

) Templates provide parameterized types, which is capable of passing a type name as a recipe for building a class or a function.
) Changes defining a template class:
1 preface class and method definition with

template <class Type>

Here type serves as a generic type specifier(built-in types, classes, etc.)
2 The method name will be altered from

bool Stack::push(const Item & item)
{
    ...
}

to

bool Stack<Type>::push(const Type & item)
{
    ...
}

) A particular actualization of a such a template is called instantiation.
Here comes the class definition and class methods file:

// stacktp.h -- a stack template
#ifndef STACKTP_H_INCLUDED
#define STACKTP_H_INCLUDED

template <class Type>
class stack
{
private:
    enum {MAX = 10};
    Type items[MAX];
    int top;
public:
    Stack();
    bool isempty();
    bool isfull();
    bool push(const Type & item);
    bool pop(Type & item);
};

template <class Type>
Stack<Type>::Stack()
{
    top = 0;
}

template <class Type>
bool Stack<Type>::isempty()
{
    return top == 0;
}

template <class Type>
bool Stack<Type>::isfull()
{
    return top == MAX;
}

template <class Type>
bool Stack<Type>::push(const Type & item)
{
    if (top < MAX)
    {
        items[top++] = item;
        return true;
    }
    else
        return false;
}

template <class Type>
bool Stack<Type>::pop(Type & item)
{
    if (top > 0)
    {
        item = items[top--];
        return true;
    }
    else
        return false;
}

#endif // STACKTP_H_INCLUDED

) To use template classes, you generate template class in this way:

Stack<int> kernels;
Stack<string> colonels;

Here comes the code:

// stacktem.cpp -- testing the template stack class
#include <iostream>
#include <string>
#include <cctype>
#include "stacktp.h"
using std::cin;
using std::cout;

int main()
{
    Stack<std::string> st;
    char ch;
    std::string po;
    cout << "Please enter A to add a purchase order,
"
         << "P to process a PO, or Q to quit.
";
    while (cin >> ch && std::toupper(ch) != 'Q')
    {
        while (cin.get() != '
')
            continue;
        if (!std::isalpha(ch))
        {
            cout << 'a';
            continue;
        }
        switch(ch)
        {
        case 'A':
        case 'a':
            cout << "Enter a PO number to add: ";
            cin >> po;
            if (st.isfull())
                cout << "stack already full
";
            else
                st.push(po);
            break;
        case 'P':
        case 'p':
            if (st.isempty())
                cout << "stack already empty
";
            else
            {
                st.pop(po);
                cout <<"PO #" << po << " popped
";
                break;
            }
        }
        cout << "Please enter A to add a purchase order,
P to process a PO, or Q to quit.
";
    }
    cout << "Bye
";
    return 0;
}

) To use a stack of pointers to strings, you need to have each pointer point to a separate string to work well.

// stcktp1.h -- modified Stack template
#ifndef STCKTP1_H_INCLUDED
#define STCKTP1_H_INCLUDED

template <class Type>
class Stack
{
private:
    enum {SIZE = 10};
    int stacksize;
    Type * items;
    int top;
public:
    explicit Stack(int ss = SIZE);
    Stack(const Stack & st);
    ~Stack() {delete [] items;}
    bool isempty() {return top == 0;}
    bool isfull() {return top == stacksize;}
    bool push(const Type & item);
    bool pop(Type & item);
    Stack & operator=(const Stack & st)
};

template <class Type>
Stack<Type>::Stack(int ss) : stacksize(ss), top(0)
{
    items = new Type [stacksize];
}

template <class Type>
Stack(Type)::Stack(const Stack & st)
{
    stacksize = st.stacksize;
    top = st.top;
    items = new Type [stacksize];
    for (int i = 0; i < top; i++)
        items[i] = st.items[i];
}

template <class Type>
bool Stack<Type>::push(const Type & item)
{
    if (top < stacksize)
    {
        items[top++] = item;
        return true;
    }
    else
        return false;
}

template <class Type>
bool Stack<Type>::pop(Type & item)
{
    if (top > 0)
    {
        item = items[--top];
        return true;
    }
    else
        return false;
}

template <class Type>
Stack<Type> & Stack<Type>::operator=(const Stack<Type> & st)
{
    if (this = &st)
        return *this;
    delete [] items;
    stacksize = st.stacksize;
    top = st.top;
    items = new Type[stacksize];
    for (int i = 0; i < top; i++)
        items[i] = st.items[i];
    return *this;
}

#endif // STCKTP1_H_INCLUDED

Noteworthy:
The prototype for assignment operator declared the return type of the method as Stack rather than Stack:

Stack & operator=(const Stack & st);

This is an abbreviation used only in class scope.
) Here comes the code that uses the simplified version of stack:

// stkoptr1.cpp -- testing stack of pointers
#include <iostream>
#include <cstdlib>
#include <ctime>
#include "stcktp1.h"
const int Num = 10;
int main()
{
    std::srand(std::time(0));
    std::cout << "Please enter stack size: ";
    int stacksize;
    std::cin >> stacksize;
    Stack<const char *> st(stacksize);

    const char * in[Num] = {"a","b","c","d","e","f","g","h","i","j"};
    const char * out[Num];

    int processed = 0;
    int nextin = 0;
    while (processed < Num)
    {
        if (st.isempty())
            st.push(in[nextin++]);
        else if (st.isfull())
            st.pop(out[processed++]);
        else if (std::rand() % 2 && nextin < Num)
            st.push(in[nextin++]);
        else
            st.pop(out[processed++]);
    }
    for (int i = 0; i < Num; i++)
        std::cout << out[i] << std::endl;

    std::cout << "Bye
";
    return 0;
}

) Next let's come to an array template example:

// arraytp.h -- Array Template
#ifndef ARRAYTP_H_INCLUDED
#define ARRAYTP_H_INCLUDED

#include <iostream>
#include <cstdlib>

template <class T, int n>
class ArrayTP
{
private:
    T ar[n];
public:
    ArrayTp() {}
    explicit ArrayTP(const T & v);
    virtual T & operator[] (int i);
    virtual T operator[] (int i) const;
};

template <class T, int n>
ArrayTP<T,n>::ArrayTP(const T & v)
{
    for (int i = 0; i < n; i++)
        ar[i] = v;
}

template <class T, int n>
T & ArrayTP<T,n>::operator[](int i)
{
    if (i < 0 || i >= n)
    {
        std::cerr << "Error in array limits: " << i << " is out of range
";
        std::exit(EXIT_FAILUER);
    }
    return ar[i];
}

template <class T, int n>
T ArrayTP<T,n>::operator[](int i) const
{
    if (i < 0 || i >= n)
    {
        std::cerr << "Error in array limits: " << i << " is out of range
";
        std::exit(EXIT_FAILURE);
    }
    return ar[i];
}

#endif // ARRAYTP_H_INCLUDED

Noteworthy
1 Note the template heading:

template <class T, int n>

This second parameter is called a non-type, as it acts as a particular type. You can use the template in this way:

ArrayTP<double, 12> eggweights;

This initializes an array of 12 doubles called eggweights.
2 Advantage and drawback
Advantage: fast execution, free from new and delele
Drawback: Each array size generate its own template

) As normal classes, you could also use template classes for inheritance or containment.
You could also use templates recursively:

ArrayTP< ArrayTP<int,5>, 10> twodee;

This is the same effect as

int twodee[10][5];

Here comes an example using the recursive call of template to create a two-dimensional array:

template <class T, int n>
class ArrayTP
{
private:
    T ar[n];
public:
    ArrayTP() {};
    explicit ArrayTP(const T & v);
    virtual T & operator[](int i);
    virtual T operator[](int i) const;
};

) You could also use templates with different types combined:

template <class T1, class T2>

Here comes the code using this trick with a Pair class:

// pairs.cpp -- defining and using a Pair template
#include <iostream>
#include <string>
template <class T1, class T2>
class Pair
{
private:
    T1 a;
    T2 b;
public:
    T1 & first();
    T2 & second();
    T1 first() const { return a;}
    T2 second() const { return b;}
    Pair(const T1 & aval, const T2 & bval) : a(aval), b(bval) {}
    Pair() {}
};

template <class T1, class T2>
T1 & Pair<T1,T2>::first()
{
    return a;
}

template <class T1, class T2>
T2 & Pair<T1,T2>::second()
{
    return b;
}

int main()
{
    using std::cout;
    using std::endl;
    using std::string;
    Pair<string,int> ratings[4] =
    {
        Pair<string,int>("a",1),
        Pair<string,int>("b",2),
        Pair<string,int>("c",3),
        Pair<string,int>("d",4),
    };

    int joints = sizeof(ratings) / sizeof(Pair<string,int>);
    cout << "Rating:	 Eatery
";
    for (int i = 0; i < joints; i++)
        cout << ratings[i].second() << ":	 " << ratings[i].first() << endl;
    cout << "Oops! Revised rating:
";
    ratings[3].first() = "g";
    ratings[3].second() = 6;
    cout << ratings[3].second() << ":	 " << ratings[3].first() << endl;
    return 0;
}

) You can provide default values for type parameters:

template <class T1, class T2 = int> class Topo {...}

) Template specializations
1 Implicit instantiation
When an object of the desired type is declared, the compiler generates a specialized class definition, using the recipe provided by the template:

ArrayTP<double, 30> * pt;
pt = new ArrayTP<double, 30>;

The compiler only generates a class for ArrayTP<double, 30> at the second sentence because only the second sentence requires declaration of a specific object of the class ArrayTP<double, 30>.
2 Explicit instantiation
When you explicitly use the keyword template and desired type to declare a class, the compiler generates one with the specific data types according to the template instructions even if there is no object of the class needed currently:

template class ArrayTP<string, 100>;

3 Explicit specialization
In some of the cases, the template's methods might work differently for one specific type, so you might want to single out the desired type's method implementations. A specialized class template definition has the following form:

template <> class Classname<specialized-type-name> { ... };

for example, after you explicit specialized template <> class Thing<char *> { ... }, next time you require a class of the char * type, the compiler would use the specialized version rather than generating one by the template.

) Member templates
A template could be a member of a structure, class or template class:

// tempmemb.cpp -- template members
#include <iostream>
using std::cout;
using std::endl;
template <typename T>
class beta
{
private:
    template <typename V>
    class hold
    {
    private:
        V val;
    public:
        hold(V v = 0) : val(v) {}
        void show() const {cout << val << endl;}
        V  Value() const {return val;}
    };
    hold<T> q;
    hold<int> n;
    public:
        beta(T t, int i) : q(t), n(i) {}
        template<typename U>
        U blab(U u, T t) { return (n.Value() + q.Value()) * u / t;}
        void Show() const { q.show(); n.show();}
};

int main()
{
    beta<double> guy(3.5, 3);
    cout << "T was set to double
";
    guy.Show();
    cout << "V was set to T, which is double, then V was set to int
";
    cout << guy.blab(10,2.3) << endl;
    cout << "U was set to int
";
    cout << guy.blab(10.0, 2.0) << endl;
    cout << "U was set to double
";
    cout << "Done
";
    return 0;
}

) Templates could also be parameters for templates:

template <template <typename T> class Thing>

Here template <typename T> class is the type and Thing is the parameter. View an example:

// tempparm.cpp -- templates as parameters
#include <iostream>
#include "stacktp.h"

template <template <typename T> class Thing>
class Crab
{
private:
    Thing<int> s1;
    Thing<double> s2; // Thing is the template parameter
public:
    Crab() {};
    bool push(int a, double x) { return s1.push(a) && s2.push(x);}
    bool pop(int & a, double & x) { return s1.pop(a) && s2.pop(x);}
};

int main()
{
    using std::cout;
    using std::cin;
    using std::endl;
    Crab<Stack> nebula; // send Stack template as parameter to template class Crab
    int ni;
    double nb;
    cout << "Enter int double pairs, such as 4 3.5 (0 0 to end):
";
    while (cin >> ni >> nb && ni > 0 && nb > 0)
    {
        if (!nebula.push(ni,nb))
            break;
    }

    while (nebula.pop(ni,nb))
        cout << ni << ", " << nb <<endl;
    cout << "Done.
";

    return 0;
}

) Template classes and friends
1 Non-template friend functions to template classes
This means that the function is friend to all possible instantiations of the tempalate, use this form:

template <class T>
class HasFriend
{
    friend void report(HasFriend<T> &);
    ...
};

In this case report could accept a object of specific type as parameter.
Here comes an example:

// frnd2tmp.cpp -- template class with non-template friends
#include <iostream>
using std::cout;
using std::endl;

template <typename T>
class HasFriend
{
private:
    T item;
    static int ct;
public:
    HasFriend(const T & i) : item(i) {ct++;}
    ~HasFriend() { ct--; }
    friend void counts();
    friend void reports(HasFriend<T> &);
};

template <typename T>
int HasFirned<T>::ct = 0;

void counts()
{
    cout << "int count: " << HasFriend<int>::ct << "; ";
    cout << "double conut: " << HasFriend<double>::ct << "
";
}

void reports(HasFriend<int> & hf)
{
    cout << "HasFriend<int>: " << hf.item << endl;
}

void reports(HasFriend<double> & hf)
{
    cout << "HasFriend<double>: " << hf.item << endl;
}

int main()
{
    cout << "No objects declared: ";
    counts();
    HasFriend<int> hfi1(10);
    cout << "After hfi1 declared: ";
    counts();
    HasFriend<int> hfi2(20);
    cout << "After hfi2 declared: ";
    counts();
    HasFriend<double> hfdb(10.5);
    cout << "After hfdb declared: ";
    counts();
    reports(hfi1);
    reports(hfi2);
    reports(hfdb);

    return 0;
}

2 Bound template friend functions to template classes
This means that the type of the friend is determined by the type of class when it is instantiated.

3 Unbound template friend functions to template classes
This means that all specializations of the friend are friends to each specialization of the class.