Templates CS212 & CS-240

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

Template Functions Not really a function, It's the design (a pattern) of a function starts off with template –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

Template Function template 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); }

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

General Form of a Template Class template // 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; … }; Required keywords, not related to typename Name of your new class

Sample usage template class mine; // declared, not defined yet class mine *mineptr; // declare pointer class mine newone; // error, unknown size template class mine {// template class defined here }; //"newone wants to be a "class template" // "mine" is the "template class"

MemoryCell Template class template 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; }

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

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

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

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 myIntStack; –to define a stack of doubles called myDblStack you would use: stack myDblStack; –to define a stack of people called myFolks you would use: stack myFolks;

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