Templates

1
Templates

• CS-240
• Dick Steflik
• DJ. Foreman

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 ltclass namegt
• 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
  ltclass obj1, class obj2, class obj3gt

4
Template Function
template ltclass Tgt T sum3 ( T a , T b , T c)
return (abc)
int main ( ) int l,m,n double r,s,t
/ use sum3 to sum sets variables of
different types / cout ltlt sum3 (l,m,n)
ltlt ltlt 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 lttypename Tgt // 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 ltclass Tgt class mine // declared, not
  defined yet
• class mine ltintgt mineptr // declare pointer
• class mineltintgt newone // error, unknown size
• template ltclass Lgt class mine
• // template class defined here
• //"newone wants to be a "class template"
• // "mine" is the "template class"

8
MemoryCell Template class
template ltclass Tgt 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 ltclass Tgt 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 ltclass
Tgt MemoryCellltTgt MemoryCell (const T initVal)
storedValue(initVal) // code for default
constructor (if any) template ltclass Tgt const T
MemoryCellltTgt read ( ) const return
storedValue template ltclass Tgt void
MemoryCellltTgt 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
• stackltintgt myIntStack
• to define a stack of doubles called myDblStack
  you would use
• stackltdoublegt myDblStack
• to define a stack of people called myFolks you
  would use
• stackltpeoplegt myFolks

13
Muddying the waters a bit

• lttypename T, class Cgt // uses items T in
  container C
• class Myclass
• public
• Myclass()
• void push( const T )
• private
• C item
• Myclass ltint, Listltintgt gt newone // now create
  one