1. Templates CS-240 Dick Steflik & DJ. Foreman

2. Reuse Templates allow us to get more mileage out of the classes we create by allowing the user to supply certain attributes at compile time. Attributes are specified in the template definition and are resolved by having the compiler do (behind the scenes) text substitutions by applying the template parameter to the template body. Think of it like doing text “replaces” in a text editor or wordprocessor

3. Template Functions A template function isn’t really a function, its the design (a pattern) of a function starts off with template –in the function body, occurrences of text will be replaced with actual type of submitted parameter –typename may be substituted for class multiple substitutions can be specified by using

4. 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); }

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 // 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

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

8. 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; }

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 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 MemoryCell :: MemoryCell (const T & initVal) : storedValue(initVal) { } template const T & MemoryCell :: read ( ) const { return storedValue; } template void MemoryCell :: 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 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;

13. 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