Using Templates

1
Using Templates
11

• Object-Oriented Programming Using C
• Second Edition

2
Objectives
11

• In this chapter, you will learn
• About the usefulness of function templates
• About the structure of function templates
• How to overload function templates
• How to create function templates with multiple
  data types
• How to create function templates with multiple
  parameterized types

3
Objectives
11

• In this chapter, you will learn
• How to override a function templates implicit
  type
• How to use multiple explicit types when you call
  a function template
• How to use function templates with classes
• About template classes and how to create them
• About container classes and how to create them

4
Understanding the Usefulness of Function
Templates
11

• The C compiler determines the functions
  argument types when the function is created and
  compiled
• Once the function is created, the argument types
  remain fixed
• Overloading involves writing two or more
  functions with the same name but different
  argument lists
• It allows you to employ polymorphism, using a
  consistent message that acts appropriately with
  different objects
• A reverse() function might change the sign of a
  number if a numeric variable is passed to it

5
Understanding the Usefulness of Function
Templates
11
6
Creating Function Templates
11

• In C, you can create functions that use
  variable types
• These function templates serve as an outline, or
  template, for a group of functions that differ in
  the types of parameters they use
• A group of functions that generates from the same
  template is often called a family of functions
• In a function template, at least one argument is
  generic, or parameterized, meaning that one
  argument can stand for any number of C types
• C also allows you to define macros, which
  permit generic substitution

7
Creating Function Templates
11

• Before you code a function template, you must
  include a template definition with the following
  information
• The keyword template
• A left angle bracket (lt)
• A list of generic types, separated with commas if
  more than one type is needed
• A right angle bracket (gt)
• Each generic type in the list of generic types
  has two parts
• The keyword class
• An identifier that represents the generic type

8
Creating Function Templates
11

• Using the keyword class in the template
  definition does not necessarily mean that T
  stands for a programmer-created class type, but
  it may

Ex11-1
9
Using Multiple Arguments to Function Templates
11

• Function templates can support multiple
  parameters

10
Using Multiple Arguments to Function Templates
11
Ex11-1

• In steps listed on pages 409 and 410 of the
  textbook, you define a function that displays the
  smallest of any of three same-type arguments it
  receives

11
Overloading Function Templates
11
Ex11-2

• You overload functions when you create functions
  with the same name but with different argument
  lists
• You can overload function templates, as long as
  each version of the function takes different
  arguments, allowing the compiler to distinguish
  between them

12
A main() Function that Uses the Overloaded
invert() Function Template
11
13
Overloading Function Templates
11
Ex11-3

• Using the steps on pages 412 and 413 of the
  textbook, you overload the displaySmallest()
  function template to accept two as well as three
  arguments

14
Using More than One Type in a Function Template
11

• Like other functions, function templates can use
  variables of multiple types
• Suppose you want to create a function template
  that displays a value a given number of times
• The value could be any type, but the number of
  times to repeat the value is an integer
• It is perfectly legal to include some
  nonparameterized types in the function argument
  list, along with the parameterized ones

15
RepeatValue Program
11
Ex11-4
16
Output of RepeatValue Program
11
17
Using More than One Parameterized Type in a
Function Template
11

• To create a function template that employs
  multiple generic types, you simply use a unique
  type identifier for each type
• Two generic types, T and U, are defined
• The first parameterized type, T, can stand for
  any type
• The second type, U, can stand for the same type,
  or any other type
• Figure 11-12 includes a demonstration main()
  function that passes a variety of arguments to
  whichIsLarger(), and Figure 11-13 shows the
  results

18
whichIsLarger() Function and main() Program
11
Ex11-5
19
Output of whichIsLarger Program
11
20
Explicitly Specifying the Type in a Function
Template
11

• When you call a function template, the arguments
  to the function dictate the types to be used
• To override a deduced type, when you call a
  function template you can explicitly code a type
  within angle brackets immediately following the
  function name in the function call
• You explicitly name a type by using the type name

21
Program that Uses an Explicit Type for a
Functions Parameterized Type
11
Ex11-6
22
Explicitly Specifying the Type in a Function
Template
11

• The main() program in Figure 11-15 calls the
  function template three times, using an integer,
  a double, and a double converted to an integer,
  respectively

23
Using Multiple Explicit Types in a Function
Template
11

• You can use multiple explicit types when you call
  a template function
• If you want the return value of a template
  function sometimes to be the same type as the
  argument, and sometimes to be a different type,
  write the function template with two
  parameterized types
• Additionally, you can exercise the option to
  explicitly name one or both types

24
Using Multiple Explicit Types in a Function
Template
11

• The main() program in Figure 11-17 uses the
  function in several ways
• Explicitly codes int for the T type and passes an
  integer to implicitly assign the U type
• Explicitly codes int for the T type and passes a
  double to implicitly assign the U type
• Explicitly codes int for the T type and
  explicitly codes a double for the U type
• Explicitly codes int for both T and U

25
Using Multiple Explicit Types in a Function
Template
11

• Figure 11-18 shows the output of the program in
  Figure 11-17
• The explanation of the output is as follows
• When tripleVal() receives the integer 22 as an
  argument, triples it, and returns the integer
  result , the output is 66
• When tripleVal() receives the double 8.88 as an
  argument, triples it to 26.64, stores the result
  in an integer, and returns the integer result,
  the output is the truncated result, 26. This is
  true whether tripleVal() receives 8.88 as a
  double implicitly or explicitly
• When 8.88 is explicitly received as an integer,
  it receives an 8. The output tripled value is 24

26
Using Multiple Explicit Types in a Function
Template
11
Ex11-7
27
Using Function Templates with Class Objects
11

• When programming in an object-oriented
  environment, you naturally want your function
  templates to work with class objects as well as
  with scalar variables
• Function templates work just as well with classes
  as they do with simple data types
• Your only additional responsibility is to ensure
  that any operations used within the function
  template have been defined for the class objects
  passed to the function templates

28
The PhoneCall Class
11
Ex11-8
29
Using Function Templates with Class Objects
11

• Figure 11-20 shows a PhoneCall class containing
  private data members that store the phone number,
  length of call, and code
• The program in Figure 11-21 declares a PhoneCall
  object and provides initial values for its fields
• In the set of steps provided on pages 421 to 423
  of the textbook, you create an Inventory class
• The class includes an overloaded insertion
  operator and an overloaded less than operator

30
Using Function Templates with Class Objects
11
Ex11-8
31
Output of SmallestTemplate3 Program
11
Ex11-9
32
Using Template Classes
11

• Function templates allow you to create generic
  functions that have the same bodies but can take
  different data types as parameters
• In some situations classes are similar and you
  want to perform very similar operations with them
• If you need to create several similar classes,
  you might consider developing a template class, a
  class in which at least one type is generic or
  parameterized

33
Using Template Classes
11

• The template class provides the outline for a
  family of similar classes
• To create a template class, you begin with the
  template definition, just as you do with a
  function template
• The class in Figure 11-24 is named Number
• Its private member, theNumber, may be of any type

34
The Number Class Definition
11
35
Creating a Complete Class Template
11

• Figure 11-25 shows the class definition for the
  Number class, along with the implementation of
  the Number class functions
• You can see in Figure 11-25 that the definition
  templateltclass Tgt also is required before the
  definition of the displayNumber() function, so as
  to identify the T in the class name, NumberltTgt
• The displayNumber() function always displays
  Number just before the value of theNumber
• Figure 11-26 contains a main() function that
  declares three Number objects constructed using
  integer, double, and character argument,
  respectively

36
Creating a Complete Class Template
11
37
Creating a Complete Class Template
11
Ex11-10
38
Using Container Classes
11

• A container class is a template class that has
  been written to perform common class tasks the
  purpose of container classes is to manage groups
  of other classes
• A common programming task that is used in a
  variety of applications is the construction of a
  linked list
• A linked list is a chain of objects, each of
  which consists of at least two partsthe usual
  components of the object itself and a pointer to
  another object

39
Using Container Classes
11

• The diagram in Figure 11-28 illustrates a linked
  list of Students
• No matter what types of objects are linked,
  procedures must be developed to establish links
  between objects and to insert new objects into
  appropriate spots within the linked list
• The procedures include assigning the correct
  linking pointer values to the new list members
• Other common procedures are deleting a member
  from the list, reordering a list, and retrieving
  and displaying the objects from a list

40
A Student Linked List
11
41
Creating an Array Template Class
11

• When you create an array, you create a list of
  same-type objects at adjacent memory locations
• You perform many standard operations on array
  data, no matter what type is involved
• You can create a generic Array class with two
  private data members a pointer to the beginning
  of the array, and an integer representing the
  size of the array

42
The Array Class
11
43
Creating an Array Template Class
11

• The Array class constructor assigns the
  arguments array address to the Array class array
  address, and assigns the arguments array size to
  the Array class member size
• The showList() function displays each element of
  the Array, from element 0 up through one less
  than size
• Figure 11-30 shows a Book class, and Figure 11-31
  shows a Client class
• Neither contains anything unusual you have
  created many similar classes

44
The Book Class
11
45
The Client Class
11
46
Creating an Array Template Class
11

• Figure 11-32 shows a main() function that
  contains several types of arrays
• The program in Figure 11-32 is divided into four
  parts, which are
• An array named someInts is initialized with three
  integers
• An array named someDoubles is initialized with
  four doubles
• A two-element Book array uses the Book class
  shown in Figure 11-30. The two Books receive
  values through the setBook() function
• A four-element Clients array uses the Client
  class shown in Figure 11-31. The Clients receive
  values through the setClient() function

47
Program Using the Array Container Class
11
48
Creating an Array Template Class
11
Ex11-11

• You can see from Figure 11-33 that when you use
  the showList() function, each list appears
  correctly no matter how many elements the array
  contains

49
Summary
11

• When the logic of several functions is similar,
  writing the code to overload the functions
  becomes tedious
• A function template is a function that serves as
  an outline, or template, for a group of functions
  that differ in the types of parameters they use
• You can overload function templates, as long as
  each version of the function takes different
  arguments, allowing the compiler to distinguish
  between them

50
Summary
11

• In addition to a parameterized variable, function
  templates can contain multiple arguments and
  internal variables that are not generic
• Function templates can have multiple
  parameterized types you use a unique type
  identifier for each type
• When you call a function template, the compiler
  implicitly deduces the correct types to use
  within the function template

51
Summary
11

• You can use multiple explicit types when you call
  a function template
• Function templates work just as well with classes
  as they do with simple data typesas long as you
  define all operations for the classes you use
  within the function template
• A template class is a class in which at least one
  type is generic or parameterized
• It provides the outline for a family of similar
  classes

52
Summary
11

• When you create a class template, you use the
  template definition prior to the class and prior
  to each function you write
• A container class is a template that has been
  written to perform common class tasks the
  purpose of container classes is to manage groups
  of other classes
• You create container class templates to speed up
  the development process for applications that
  require similar tasks