CSC-335 ADTs & Data Structures (Chapter 9 ADT Implementations: Templates and Standard Containers)

Instructor: Christos Kolonis

Chapter Contents
9.1 Introduction: The Evolution of Reusability and Genericity

9.2 Function Genericity Overloading and Templates

9.3 Class Genericity Templates 9.4 The vector Container

9.6 Multidimensional vectors (Optional)

Chapter Objectives
Survey how reusability themes have evolved in programming languages Study function templates Study class templates Look at vector in detail as an example of a container class template (Optional) Study multidimensional vectors

Evolution of Reusability, Genericity Major theme in development of programming languages

Reuse code Avoid repeatedly reinventing the wheel

Trend contributing to this

Use of generic code Can be used with different types of data

Evolution of Reusability, Genericity

Evolution of algorithmic features of programming languages Evolution of data features of programming languages

Niklaus Wirth (inventor of Pascal) Stressed data and algorithms cannot be separated
5

Function Genericity Overloading and Templates

Initially code was reusable by encapsulating it within functions Example lines of code to swap values stored in two variables
Instead of rewriting those 3 lines Place in a function void swap (int& first, int& second) { int temp = first; first = second; second = temp; } Then call swap(x,y);

Function Genericity Overloading and Templates

To swap variables of different types, write another function
Overloading allows functions to have same name Signature (types and numbers of parameters) keep them unique to the compiler

This could lead to a library of swap functions

One function for each standard type Compiler chooses which to use from signature

But what about swapping user defined types?

Function Templates
Note how similar each of the swap functions would be
The three places where the type is specified

What if we passed the type somehow?!! Templates make this possible

Declare functions that receive both data and types via parameter

Thus code becomes more generic

Easier to reuse

Template Mechanism
Declare a type parameter
also called a type placeholder

Use it in the function instead of a specific type.

This requires a different kind of parameter list:

void Swap(______ & first, ______ & second) { ________ temp = first; first = second; second = temp; }

Template Mechanism
The word template is a C++ keyword Specifies that what follows is
a pattern for a function not a function definition.

Normal parameters (and arguments)

appear within function parentheses

Type parameters (and arguments for class templates) appear within template angle brackets (< > ).

10

Template Mechanism
A function template cannot be split across files
specification and implementation must be in the same file

A function template is a pattern

describes how specific functions is constructed constructed based on given actual types type parameter said to be "bound" to the actual type passed to it

11

Template Mechanism

Each of the type parameters must appear at least once in parameter list of the function
compiler uses only types of the arguments in the call thus determines what types to bind to the type parameters

12

Function Template
template <typename ElementType> void Swap (ElementType &first, ElementType &second) { ElementType hold = first; first = second; second = hold; } template <class myType> void Swap (myType &first, myType &second) { ElementType hold = first; first = second; second = hold; } Int x = 10; string x = Hello;
13

string y= There; swap (x, y)

Int y = 20 swap (x, y)

Function Template
template <typename ElementType> void Swap (ElementType &first, ElementType &second) Originally, the keyword class was used instead of typename in a type-parameter list.

"class" as a synonym for "kind" or "category" specifies "type / kind" of types.

14

Function Template
<typename ElementType> names ElementType as a type parameter

The type will be determined

by the compiler from the type of the arguments passed

when Swap() is called.

15

General Form of Template

template <typename TypeParam> FunctionDefinition

or
template <class TypeParam> FunctionDefinition

where:
TypeParam is a type-parameter (placeholder)

naming the "generic" type of value(s) on which the function operates FunctionDefinition is the definition of the function, using type TypeParam.
16

Template Instantiation
The template itself does nothing specific. When the compiler encounters a template
it stores the template but doesn't generate any machine instructions.

Later, when it encounters a call to Swap() Example: Swap(int1, int2); it generates an integer instance of Swap() as shown in the next slide
17

Template Instantiation
template <class theType> void Swap (theType& first, theType& second) { theType hold = first; first = second; second = hold; } void Swap (int& first, int& second) { int hold = first; first = second; second = hold; }
18

Example: Displaying an Array

When a function template is instantiated Compiler finds type parameters in list of function template For each type parameter, type of corresponding argument determined These two types bound together

template <class T> void printArray (const T& A[], int size) { for (int i = 0; i< size, i++) cout << A[i] << ; cout << endl; }

19

9.3 Class Templates

Recall our Stack class: const int STACK_CAPACITY = 128; class Stack { /***** Function Members *****/ public: . . . /***** Data Members *****/ private: How did we create a new version of a stack for a different type of element?

int myArray[STACK_CAPACITY];
int myTop;
};
20

Type-Independent Container
Use a class template:
the class is parameterized it receives the type of data stored in the class via a parameter (like function templates).

Recall

template <class StackElement, int theMaxSize> __________________________________ class Stack { /***** Function Members *****/ public: . . . StackElement is /***** Data Members *****/ a blank type (a private: type placeholder) StackElement myArray[theMaxSize]; to be filled in later. int myTop; };

21

General Form Of Class Template Declaration

template <typename TypeParam > template <class TypeParam> or

class SomeClass { // ... members of SomeClass ... }; More than one type parameter may be specified: template <class TypeParam_1,..,class TypeParam_N> class SomeClass { // ... members of SomeClass ... };

22

Instantiating Class Templates

Instantiate it by using declaration of form ClassName<Type> object;

Passes Type as an argument to the class template definition. Examples: Stack<int, 100> intSt; Stack<string, 50> stringSt; Compiler will generate two distinct definitions of Stack
two instances one for ints and one for strings.

23

Rules For Class Templates

1. Definitions of member functions outside class declaration must be function templates. 2. All uses of class name as a type must be parameterized.

3. Member functions must be defined in the same file as the class declaration.

24

Applying the Rules to Our Stack Class

Recall how we specified the prototypes in the class

Used StackElement
Thus no changes needed all rules OK

Apply Rule 1
Each member functions definition preceded by template <class StackElement>

25

Applying the Rules to Our Stack Class Apply Rule 2

The class name Stack preceding the scope operator (::) is used as the name of a type must therefore be parameterized. template <class StackElement> void Stack<StackElement>::push(const StackElement & value) { /* ... body of push() ... */ }

Apply Rule 3 : specification, implementation in same file

26

Applying the Rules to Friend Functions

Consider the addition of a friend function operator<< Second parameter is of type Stack, must parameterized

Non-member functions are also governed by the three rules

friend ostream& operator<<(ostream& out, const Stack<StackElement>& st);

27

Applying the Rules to Friend Functions

When defining the operator<< function

It must be defined as a function template

template<class StackElement> ostream& operator<<(ostream& out, const Stack<StackElement>& st) { ...... ...... ...... }
28

Stack Class Template

Note application of all these principles Fig. 9.3, a Stack class template
Note that there is not a separate .cpp file

Fig. 9.4, a driver program to illustrate use of the class

Note that templates may have more than one type parameter
May also have ordinary value parameters

Thus possible to specify a Stack class differently

Could specify with a dynamic array and pass an integer for the capacity

29

STL (Standard Template Library)

A library of class and function templates

Components: 1. Containers:
Generic "off-the-shelf" class templates for storing collections of data

2.

Algorithms:
Generic "off-the-shelf" function templates for operating on containers

3.

Iterators:
Generalized "smart" pointers that allow algorithms to operate on almost any container

30

Standard Template Library

Example of a specific
container class

iterator algorithm

31

STL's 10 Containers
Kind of Container Sequential: Associative: Adapters: Non-STL: STL Containers
deque, list, vector
map, multimap, multiset, set priority_queue, queue, stack bitset, valarray, string

32

9.4 The vector Container

A type-independent pattern for an array class
capacity can expand

self contained

Declaration template <typename T> class vector

. . .

} ;

33

The vector Container

Constructors
vector<int> v, v1(100), v2(100, 0);

34

vector Operations
Information about a vector's contents
v.size() v.empty() v.capacity() v.reserve()

Adding, removing, accessing elements

v.push_back() v.pop_back() v.front() V = < 10, 20, 30>; V.pop_back();
35

vector Operations
Assignment v1 = v2

Swapping v1.swap(v2)

Relational operators == implies element by element equality less than < behaves like string comparison
36

Increasing Capacity of a Vector

When vector v becomes full
capacity increased automatically when item added

Algorithm to increase capacity of vector<T>

Allocate new array to store vector's elements use T copy constructor to copy existing elements to new array Store item being added in new array Destroy old array in vector<T> Make new array the vector<T>'s storage array

37

Increasing Capacity of a Vector

Allocate new array
Capacity doubles when more space needed

Elements copied to new array

38

Increasing Capacity of a Vector

Item being added now stored

Destroy old array

Make new array the vector's storage area

39

Iterators
Note from table that a subscript operator is provided
BUT this is not a generic way to access container elements

STL provides objects called iterators

can point at an element can access the value within that element can move from one element to another

They are independent of any particular container thus a generic mechanism

40

Iterators
Given a vector which has had values placed in the first 4 locations:
vector<int> v 9
v.begin()

15

3
v.end()

v.begin() will return the iterator value for the first slot, v.end() for the next empty slot
41

Iterators
Each STL container declares an iterator type can be used to define iterator objects To declare an iterator object the identifier iterator must be preceded by
name of container scope operator ::

Example:

vector<int>:: vecIter = v.begin()

42

Iterators
Basic operators that can be applied to iterators:
increment operator ++ decrement operator -dereferencing operator * Assignment = Addition, subtraction +, -, +=, -= vecIter + n returns iterator positioned n elements away

Subscript operator [ ] vecIter[n] returns reference to nth element from current

position v[n] vecIter + 3

43

Iterators
Contrast use of subscript vs. use of iterator
ostream & operator<<(ostream & out, const vector<double> & v) { for (int i = 0; i < v.size(); i++) out << v[i] << " "; return out; }

for (vector<double>::iterator it = v.begin(); it != v.end(); it++) out << *it << " ";

44

Iterator Functions
Note Table 9-5, pg 490 Note the capability of the last two groupings
Possible to insert, erase elements of a vector anywhere in the vector Must use iterators to do this Note also these operations are as inefficient as for arrays due to the shifting required

45

Contrast Vectors and Arrays

Vectors Capacity can increase A self contained object Is a class template Has function members to do tasks Can be returned from the function Can be passed as reference or value just like other primitive data types to the function
46

Arrays Fixed size, cannot be changed during execution Cannot "operate" on itself Must "re-invent the wheel" for most actions Cannot be returned from the function Always is passed as reference to the function

Multidimensional vectors (Optional) Consider a vector whose elements are themselves vectors A vector of vectors Example
vector < vector<double> > table (ROWS, vector <double> (COLUMNS, 0, 0);

47

Two-D vector Operations

Subscript
Single table[0] refers to one row of table

Double-subscript table[1][3] refers to an element within specified row

48

Two-D vector Operations

The size() method
table.size() gives number of rows table[0].size() gives number of elements in a row (effectively the number of columns)

The push_back() method

table.push_back (vector<double>(COLUMNS,0.0); adds another row To add another column, what would it take?? Note: possible to create tables with rows of different sizes!

49

STL's deque Container

As an ADT, a deque is a double-ended queue
It is a sequential container Acts like a queue (or stack) on both ends It is an ordered collection of data items Items can only be added or removed at the ends

50

deques
Basic operations
Construct a deque (usually empty): Check if the deque is empty Push_front:
Add an element at the front of the deque

Push_back:
Add an element at the back of the deque

51

deques
Basic operations (ctd.) Front:
Retrieve the element at the front of the deque

Back:
Retrieve the element at the back of the deque

Pop_front:
Remove the element at the front of the deque

Pop_back:
Remove the element at the back of the deque View Fig. 9.7, Demonstration of STL's deque

52

STL's deque Class Template

Has the same operations as vector<T> except there is no capacity() and no reserve()

Has two new operations: d.push_front(value); Push copy of value at front of d

d.pop_front(value); Remove value at the front of d

53

vector vs. deque

vector
Capacity of a vector must be increased It must copy the objects from the old vector to the new vector

deque

With deque this copying, creating, and destroying is avoided. Once an object is constructed, it can stay in the same memory locations It must destroy each object as long as it exists in the old vector If insertions and deletions

A lot of overhead!

take place at the ends of the deque.

54