Templates

1. Templates CS212 & CS-240

2. Reuse • Templates allow extending our classes • Allows the user to supply certain attributes at compile time. • Attributes specified in template definition • Resolved by compiler via text substitutions • Applies template parameter to template body. • Like text “replace” in a wordprocessor

3. Template Functions • Not really a function, • It's the design (a pattern) of a function • starts off with template <class name> • in function body, name will be replaced with actual type of submitted parameter • typename may be substituted for class • multiple substitutions can be specified by using <class obj1, class obj2, class obj3>

4. Template Function template <class T> T sum3 ( T a , T b , T c) { return (a+b+c); } int main ( ) { int l,m,n; double r,s,t; /* use sum3 to sum sets variables of different types */ cout << sum3 (l,m,n) << “ “ << sum3 (r,s,t); }

5. Template class • Like a function template is not a function a template class is not a class, but it is a pattern for the compiler on how to define the class • template parameters are specified the same as for template functions • text substitutions are done explicitly not implicitly like for template functions

6. General Form of a Template Class template <typename T> // choices are: class or typename class templateClass { public: // constructor templateClass (const T& item); // member functions T f( ); void g (const T& item); private: T dataValue; … }; Name of your new class Required keywords, not related to typename

7. Sample usage template <class T> class mine; // declared, not defined yet class mine <int> *mineptr; // declare pointer class mine<int> newone; // error, unknown size template <class L> class mine {// template class defined here }; //"newonewants to be a "class template" // "mine" is the "template class"

8. MemoryCell Template class template <class T> class MemoryCell { public: /* constructor */ explicit MemoryCell( const T & initVal = T( ) ) : storedValue(initValue){ } /* accessor functions */ const T & read ( ) const { return storedValue; } void write (const T & x) { storedValue = x; } private: T storedValue; }

9. MemoryCell class • Notice, previous examples use “inline” code to define the class • Notice also that the syntax is slightly different • The next example separates into interface and implementation

10. MemoryCell interface template <class T> class MemoryCell { public: explicit MemoryCell (const T & initVal = T( )); const T & read( ) const; void write (const T & x); private: T storedValue; }

11. MemoryCell implementation #include “MemoryCell.h” template <class T> MemoryCell<T>:: MemoryCell (const T & initVal) : storedValue(initVal) {// code for default constructor (if any)} template <class T> const T & MemoryCell<T> :: read ( ) const { return storedValue; } template <class T> void MemoryCell<T> :: write (const T & x) { storedValue = x ;}

12. Using the template class • Assuming that we had defined a template class named stack • to define a stack of integers called myIntStack you would use: • stack<int> myIntStack; • to define a stack of doubles called myDblStack you would use: • stack<double> myDblStack; • to define a stack of people called myFolks you would use: • stack<people> myFolks;

13. Muddying the waters a bit <typename T, class C> // uses items T in container C class Myclass { public: ~Myclass(); // destructor void push( const T & ); private: C item; }; Myclass <int, List<int> > newone; // now create one