Universidad de Costa Rica Escuela de Ciencias de la Computación e Informática

The Tdef.h trick to teach C++ templates

Abstract   

int main() {
    Stack_int S;
    int d = -1;

    S.Push(1);    // 1
    S.Push(2);    // 1 2
    S.Push(3);    // 1 2 3
    S.Push(4);    // 1 2 3 4
    S.Push(5);    // 1 2 3 4 5

    d = S.Pop(); // 1 2 3 4    [5]
    d = S.Count();   // 4

    S.Push(6);    // 1 2 3 4 6
    d = S.Count();   // 5
    S.Push(7);    // 1 2 3 4 6 7
    d = S.Count();   // 6

    d = S.Pop(); // 1 2 3 4 6  [7]
    d = S.Count();   // 5

    return 0;
} // main()

      Generic programming is a concept that has been developed for more than 20 years. It has always been difficult to teach, for it requires the apprentice to master basic concepts of abstraction for algorithms and data abstraction. This forces instructors to introduce these concepts in an advanced course. Since templates are "text editor polymorphism" [MDC-91], it is possible to cover them early, with simplicity and precision, based on C++ "macros". Figure 1 is a simple program that can be used to introduce the concept of container as an object used to store to other objects.

int main() {
    Stack_int S;
    // ...
} // main()

class Stack_int {
public:
    Stack_int()      { m_top = 0; return; }
    void Push(int d) { m_vec[m_top] = d; m_top++; return; }
    int  Pop()       { m_top--; return m_vec[m_top]; }
    int  Top()       { return m_vec[m_top-1]; }
    int  Count()     { return m_top; }
private:
    enum { Capacity = 132 };
    int  m_top;           // stack's top
    int  m_vec[Capacity]; // stack's array of values
}; // Stack_int

      It is easy for students to understand that a vector can be used to implement the stack operations; the implementation at the bottom of Figure 2 is familiar to them.

int main() {
    Stack_T S;
    // ...
} // main()

typedef int T;

class Stack_T {
public:
    Stack_T()      { m_top = 0; return; }
    void Push(T d) { m_vec[m_top] = d; m_top++; return; }
    T    Pop()     { m_top--; return m_vec[m_top]; }
    T    Top()     { return m_vec[m_top-1]; }
    int  Count()   { return m_top; }
private:
    enum { Capacity = 132 };
    int  m_top;           // stack's top
    T    m_vec[Capacity]; // stack's array of values
}; // Stack_T

      Figure 3 shows the result of making small changes with the text editor to obtain class "Stack_T", which has the same functionality as class "Stack_int" from Figure 2. It is simple for students to understand the advantages of a more general class when they realize that changing a single line of code can result in a generic class:
      "typedef int T;"

// Tdef.h

#ifndef Tdef_h
    #define Tdef_h
    typedef  int T;
#endif // Tdef_h

// Tdef.h

#ifndef Tdef_h
    #define Tdef_h
    #define T int
#endif // Tdef_h

#ifndef Tdef_h
    #include "Tdef.h"
#endif // Tdef_h

class Stack_T {
public:
    Stack_T()      { m_top = 0; return; }
    void Push(T d) { m_vec[m_top] = d; m_top++; return; }
    T    Pop()     { m_top--; return m_vec[m_top]; }
    T    Top()     { return m_vec[m_top-1]; }
    int  Count()   { return m_top; }
private:
    enum { Capacity = 132 };
    int  m_top;           // stack's top
    T    m_vec[Capacity]; // stack's array of values
}; // Stack_T

      The "Tdef.h" trick is to put the line where the data type stored in the stack is defined in a header file called "Tdef.h". The main program remains the same as the one on Figure 2. At the beginning of Figure 4 there are 2 versions for "Tdef.h" which can be used to parametrize the stack. It is possible to explain how macros and the C++ preprocessor work while explaining the necessity to use the conditional compilation directives "#ifndef".

int main() {
    Stack<int> S;
    // ...
} // main()

template <class T>
class Stack {
public:
    Stack()        { m_top = 0; return; }
    void Push(T d) { m_vec[m_top] = d; m_top++; return; }
    T    Pop()     { m_top--; return m_vec[m_top]; }
    T    Top()     { return m_vec[m_top-1]; }
    int  Count()   { return m_top; }
private:
    enum { Capacity = 132 };
    int  m_top;           // stack's top
    T    m_vec[Capacity]; // stack's array of values
}; // Stack

      After having a generic class it is relatively simple to transform it into a template class, like the one in Figure 5. Many students choose to use the "Tdef.h" class without templates. They do so because while coding the compiler shows errors that are easier to understand than those of a template class, in spite of the limitation that only one data type can be used for the container.

      Using this pedagogic approach achieves very good results, for it takes about 2 hours to introduce templates after explaining the C++ preprocessor and its "macros". Since students understand how the text substitution mechanism for templates works, they can write an debug generic programs with little effort, because they first build the "Tdef.h" version and later "templatetize" it when it is debugged.

Conclusion   

      The "Tdef.h" trick has several important advantages:

• It facilitates for students and programmers to specify and implement C++ containers because the compiler better and more precisely verifies code that does not have templates because in some C++ compilers, until a template class gets instantiated with a specific type, the compiler does not even compile the template code.
• It is easier to write a program without templates than one with them.
• Although this does not mean that it is not important, this tricks helps to separate the abstraction from the implementation for containers because the container stored value becomes secondary.

Acknowledgements   

      Miguel Angel Prieto, Manuel Enrique Bermúdez and Alejandro Di Mare contributed with several observations and important suggestions to improve this work.

References   

Index   

[-]	Abstract
[-]	Conclusion
[-]	Acknowledgements
	References
	Index
	About the author
	About this document
	Beginning Index End

About the author   

Adolfo Di Mare <adolfo@di-mare.com>

About this document   

Reference:	Di Mare, Adolfo: The Tdef.h trick to teach C++ templates , Reporte Técnico ECCI-2004-01(en), Escuela de Ciencias de la Computación e Informática, Universidad de Costa Rica, 2004.
Internet:	http://www.di-mare.com/adolfo/p/tdefen.htm
Author:	Adolfo Di Mare <adolfo@di-mare.com>
Contact:	Apdo 4249-1000, San José Costa Rica Tel: (506) 207-4020       Fax: (506) 438-0139
Revision:	ECCI-UCR, Octubre 2004
Visitors: