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.5 Case Study: Counting Computer Logins 9.6 Multidimensional vectors (Optional) 9.7 Other Standard Containers deque, stack, queue 9.8 Bitsets and Valarrays (Optional)

Chapter Objectives
Survey how reusability and genericity 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 Look at some of the other C++ standard containers (deque, stack, and queue) (Optional) Introduce valarrays and bitsets as array-based templates

9.1 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

Fig. 9.1

9.2 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; }

13

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
In and of itself, the template does nothing. 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()

17

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

This process demonstrated in Fig. 9-2

18

9.3 Class Templates

Recall our Stack class:

const int STACK_CAPACITY = 128; typedef int StackElement; class Stack { /***** Function Members *****/ public: . . . /***** Data Members *****/ private: StackElement myArray[STACK_CAPACITY]; int myTop; };
19

How did we create a new version of a stack for a different type of element?

Whats wrong with typedef?

To change the meaning of StackElement
Merely change the type following typedef

Problems:
Changes the header file
Any program that uses this must be recompiled

A name declared using typedef can have only one meaning.

What if we need two stacks of different types in the same program? cannot overload like functions (same number, type, and order of parameters)

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

const int STACK_CAPACITY = 128; template <typename StackElement> __________________________________ class Stack { /***** Function Members *****/ public: . . . /***** Data Members *****/ private: StackElement myArray[STACK_CAPACITY]; int myTop; };
21

StackElement is a blank type (a type placeholder) to be filled in later.

General Form Of Class Template Declaration

template <typename TypeParam > or template

<class TypeParam> class SomeClass { // ... members of SomeClass ... };

More than one type parameter may be specified:

template <typename TypeParam1,..., typename TypeParamn> 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> intSt; Stack<string> 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 <typename 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 <typename 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<typename 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: STL Containers
deque, list, vector map, multimap, multiset, set priority_queue, queue, stack bitset, valarray, string

Adapters:

Non-STL:

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<T> v, v1(100), v2(100, val), // empty vector // 100 elements of type T // 100 copies of val

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()

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

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 Arrays Fixed size, cannot be changed during execution

A self contained object Is a class template

Cannot "operate" on itself Must "re-invent the wheel" for most actions

Has function members to do tasks

46

Case Study: Counting Computer Logins Problem: Login information for each user on a system recorded in a file. We wish to compile a log of information for distinct users Object involved is log of user's information Operations on this object include building the object by
Reading login info for user from file Searching log for user's login info Add information if not already in file

47

Case Study: Counting Computer Logins Linear search algorithm will be used Fig. 9.5 shows declaration of class LoginLog Fig 9.6 shows program to use class LoginLog

48

9.6 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);

49

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

50

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!

51

9.7 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

52

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

53

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

54

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

55

STL's deque Class Template

Like STL's vector, it has several operations that are not defined for deque as an ADT: [ ] subscript operator
insert and delete at arbitrary points in the list, same kind of iterators.

But: insertion and deletion are not efficient in fact, take longer than for vectors.

56

vector vs. deque

vector
Capacity of a vector must be increased

deque

With deque this copying, creating, and destroying is avoided. It must copy the objects from the old vector to the Once an object is constructed, it can stay in the new vector same memory locations as It must destroy each object long as it exists in the old vector If insertions and deletions A lot of overhead!
take place at the ends of the deque.

57

vector vs. deque

Unlike vectors, a deque isn't stored in a single varying-sized block of memory, but rather in a collection of fixed-size blocks (typically, 4K bytes). One of its data members is essentially an array map whose elements point to the locations of these blocks.

58

Storage for A deque

Example: a deque with 666, 777, 888, 6, 5 in this order, from front to back

When a data block gets full, a new one is allocated and its address is added to map.

59

Storage for A deque

Fig 9.8

When map gets full, a new one is allocated

The current values are copied into the middle of it. Inserts and deletes may involve crossblock element-shifting!

60

A deque-Based Stack Template Stack can become full

Possible (poor) solution was to use dynamic arrays and go through complicated algorithm to increase capacity

Better solution was to use linked-list implementation

61

STL's stack Adapter

STL stack container
Actually an adapter Indicated by container type as one of its type parameters

stack <T,

C<T> > aStack;

If no container specified stack <T> astack; Default is deque

Also possible to specify a vector or list as the container for the stack

62

STL's queue Adapter

A queue can be specified queue<T, C<T> > aQueue;
Where C may be any container supporting push_back() and pop_front()

The default container is deque

Could also use queue <T, list<T> > aQueue;

63

9.8 Bitsets
The C++ standard includes bitset as a container,
but it is not in STL.

A bitset is an array whose elements are bits.

Much like an array whose elements are of type bool,

Unlike arrays, bitset provides operations for manipulating the bits stored in it. They provide an excellent data structure to use to implement sets.

64

Bitsets
Operations provided Bitwise and &, bitwise or |, bitwise xor ^
Assignment operators Relational operators Subscript operator

Function members for bitset<10> b

b.set() b.reset() b.set (i, bv) b.reset(i) b.flip() b.test(i) b.flip(i) b.size() b.count() b.any() b.none()

65

ValArrays
The standard C++ library also provides the valarray class template,
Designed to carry out (mathematical) vector operations very efficiently. Highly optimized for numeric computations.

Operators provided
subscript assignment unary +, -, ~, ! size resize(n,val)

66

ValArrays
Auxiliary types that specify subsets of a valarray
slice_array gslice_array mask_array indirect_array

67