CHAPTER 2

STORAGE STRUCTURES

FOR

CONTAINER CLASSES

A DYNAMIC VARIABLE IS ONE

THAT IS CREATED AND DESTROYED

BY THE PROGRAMMER DURING

EXECUTION. THIS CAN SAVE A LOT

OF SPACE IN MEMORY.

DYNAMIC VARIABLES ARE STORED

IN THE HEAP, A LARGE AREA OF

MEMORY.

DYNAMIC VARIABLES ARE NEVER

ACCESSED DIRECTLY. THEY ARE

ACCESSED THROUGH POINTER

VARIABLES.

A POINTER VARIABLE

CONTAINS THE ADDRESS OF A

VARIABLE (USUALLY, A DYNAMIC

VARIABLE).

A POINTER TYPE IS A TYPE

FOLLOWED BY AN ASTERISK:

string* sPtr;

HERE, sPtr IS A POINTER VARIABLE,

SPECIFICALLY, A POINTER TO A

STRING.

TO CREATE A DYNAMIC VARIABLE,

THE new OPERATOR IS USED:

sPtr = new string;

THE EXECUTION OF THIS

STATEMENT CREATES A DYNAMIC

VARIABLE POINTED TO BY sPtr.

sPtr ?

TO ACCESS THE DYNAMIC VARIABLE,

WE DEREFERENCE THE POINTER

VARIABLE. THE DEREFERENCE

OPERATOR, ‘*’, IS PLACED

IN FRONT OF

THE POINTER VARIABLE: *sPtr

THE DYNAMIC VARIABLE CAN NOW

BE TREATED AS AN ORDINARY string

VARIABLE. FOR EXAMPLE,

*sPtr = “serene”; // note ‘*’ to left of sPtr

sPtrserene

cin >> *sPtr;while (*sPtr != "***"){ if ((*sPtr).length() <= 6) cout << *sPtr << " is a small word." << endl; else cout << *sPtr << " is not a small word." << endl; cin >> *sPtr;} // while

IN THE EXPRESSION

(*sPtr).length() <= 6

PARENTHESES AROUND *sPtr ARE

NEEDED: THE MEMBER-SELECTION

OPERATOR (THE DOT) HAS HIGHER

PRECEDENCE THAN THE

DEREFERENCE OPERATOR.

ALTERNATIVE NOTATION: THE

DEREFERENCE-AND-SELECT

OPERATOR IS ->

sPtr -> length() <= 6

THIS IS EQUIVALENT TO

(*sPtr).length() <= 6

TO DESTROY A DYNAMIC VARIABLE,THE delete OPERATOR IS USED:

delete sPtr;

THIS DEALLOCATES THE SPACE FORTHE DYNAMIC VARIABLE POINTEDTO BY sPtr. THAT SPACE CAN NOW BEALLOCATED FOR ANOTHERDYNAMIC VARIABLE.

IT IS POSSIBLE FOR A CLASS TOHAVE A FIELD WHOSE TYPE IS APOINTER TO THE CLASS-TYPEITSELF:

class node{

public:// public members

protected:double data;node* next;

} // class node

THEN WE CAN CONSTRUCT A

SEQUENCE OF NODES LIKE LINKS IN

A CHAIN:

data next data next data next

91.7 84.532.6

ARRAYS

string* words;

HERE, words CAN BE A POINTER

TO EITHER A SINGLE STRING OR

TO AN ARRAY OF STRINGS.

POINTER TO AN ARRAY OF STRINGS:

words = new string [7];

THIS CREATES AN ARRAY OF 7

EMPTY STRINGS AND STORES IN

words A POINTER TO THE ZERO-TH

ITEM IN THIS ARRAY.

words

THE INDEX OPERATOR, operator[ ], IS

USED TO REFERENCE THE

INDIVIDUAL ITEMS:

words [1] = “tranquil”;

THIS IS EQUIVALENT TO

*(words + 1) = “tranquil”;

IN GENERAL, FOR ANY ARRAY a AND

NON-NEGATIVE INTEGER i,

a [i] IS EQUIVALENT TO *(a + i)

THIS IS THE UNIVERSAL ARRAY-

POINTER LAW!

ARRAY PROPERTIES:

RANDOM-ACCESS: ANY ITEM INAN ARRAY CAN BE ACCESSED ORMODIFIED IMMEDIATELY, GIVENTHE INDEX OF THE ITEM:

for (int j = 0; j < 7; j++)cin >> words [j];

ONCE CREATED, AN ARRAY’SCAPACITY IS FIXED.

int capacity;

cin >> capacity;string* words = new string [capacity];

BUT NOTE THAT THE CAPACITYNEED NOT BE KNOWN UNTIL RUNTIME.

WHAT IF THE CAPACITY IS NOT

BIG ENOUGH? FOR EXAMPLE,

SUPPOSE capacity HAS THE VALUE 5,

AND WE WANT TO EXPAND THE

SIZE OF THE ARRAY (POINTED TO

BY) words.

capacity *= 2; // double the capacitystring* temp = new string [capacity];

for (int i = 0; i < capacity / 2; i++) temp [i] = words [i];

words = temp;

words

temp

Thesearetheoriginal

items

TO DEALLOCATE THE SPACE FOR

AN ARRAY, USE AN EMPTY INDEX:

delete[ ] words;

CONTAINER

CLASSES

A CONTAINER IS A VARIABLE THAT

CONSISTS OF A COLLECTION OF

ITEMS. FOR EXAMPLE, AN ARRAY

IS A CONTAINER.

A CONTAINER CLASS IS A CLASS

WHOSE OBJECTS ARE CONTAINERS.

THERE ARE TWO WIDELY USED

KINDS OF STRUCTURES FOR

STORING THE ITEMS IN A

CONTAINER OBJECT: AN ARRAY AND

A LINKED STRUCTURE.

IN THE FIRST STRUCTURE, ONE OF

THE FIELDS IN THE CLASS IS AN

ARRAY, AND THE ITEMS ARE

STORED IN THIS ARRAY.

ADVANTAGE: ALLOWS RANDOM-

ACCESS OF ITEMS.

DRAWBACK: LARGE-SCALE

MOVEMENT OF ITEMS FOR

INSERTING, DELETING, AND RESIZING

(DUE TO FIXED SIZE).

THERE WILL BE METHODS TO

HANDLE MOVEMENT OF ITEMS, BUT

EVEN SO, EXECUTION SPEED MAY BE

SLOW.

EXERCISE: SUPPOSE THAT A

CONTAINER CLASS HAS AN

UNDERLYING ARRAY, data, WHOSE

ITEMS ARE OF TYPE T AND WHOSE

CAPACITY IS STORED IN THE int

VARIABLE n. IF data IS FULL, WRITE

THE CODE TO DOUBLE THE CAPACITY

OF data AND STORE THE ORIGINAL

CONTENTS OF data IN THE FIRST HALF

OF data.

ANOTHER WAY TO STORE A

CONTAINER IS IN A LINKED

STRUCTURE: EACH ITEM HAS AN

ASSOCIATED LINK – THAT IS, A

POINTER – TO THE NEXT ITEM IN

THE CONTAINER.

do re mi

HERE IS THE BASIC IDEA:

TO GIVE YOU A FEEL FOR A LINKED

STRUCTURE, WE NOW DESIGN AND

IMPLEMENT A TOY CLASS, Linked.

WE START WITH A USER’S VIEW:

WHAT ARE THE RESPONSIBILITIES

OF THIS CLASS?

SPECIFICALLY, WHAT TYPE OF

ITEMS WILL THE Linked CLASS

HANDLE?

INSTEAD OF RESTRICTING THE

CLASS TO WORK WITH JUST ONE

TYPE OF ITEM, WE WILL LET THE

USER SELECT THE ITEM TYPE WHEN

THE USER DEFINES THE CONTAINER

OBJECT.

TO ALLOW THIS, WE WILL

DEFINE A TEMPLATE, OR MOLD,

THAT WILL ALLOW THE

DEFINITION, AT COMPILE-TIME, OF

A CONTAINER CLASS OF SOME

FIXED TYPE.

THE CONTAINER CLASS IS A

TEMPLATE CLASS, AND THE GIVEN

TYPE IS A TEMPLATE ARGUMENT.

FOR EXAMPLE, A USER CAN DEFINE

Linked<string> words;

Linked<double> salaries;

Linked<Employee> employees;

IN THE CONTAINER OBJECT words,

EACH ITEM WILL BE OF TYPE string,

THE TEMPLATE ARGUMENT. IT

WOULD BE AN ERROR TO TRY TO

INSERT ANYTHING BUT A string INTO

words.

THE DEFINITION OF A TEMPLATE

CLASS STARTS WITH THE

TEMPLATE PARAMETER, THE TYPE

THAT WILL BE REPLACED BY THE

TEMPLATE ARGUMENT WHEN THE

CONTAINER OBJECT IS DEFINED.

template<class T>class Linked{

RECALL THE DEFINITION OF salaries:

Linked<double> salaries;

NOTE THAT T MAY BE BUT NEED

NOT BE A CLASS: T CAN ALSO BE

double, int, AND SO ON.

RESPONSIBILITIES OF THE LinkedCLASS:

1. TO CONSTRUCT AN EMPTY LinkedOBJECT;

2. TO RETURN THE NUMBER OF ITEMSCURRENTLY STORED IN A LinkedOBJECT;

3. TO INSERT AN ITEM AT THE FRONTOF A Linked OBJECT.

METHOD INTERFACES:

// Postcondition: this Linked object is empty, that is,// it contains no items.Linked( );

// Postcondition: the number of items in this Linked// object has been returned.long size( );

// Postcondition: newItem has been inserted at the// front of this Linked object.void push_front (const T& newItem);

HERE ARE EXAMPLES OF HOW A

USER MIGHT DEFINE AND WORK

WITH Linked OBJECTS;

Linked<string> words;Linked<double> salaries;

words.push_front (“halycon”);words.push_front (“peaceful”);salaries.push_front (63000.00);

cout << words.size( ) << “ “ << salaries.size( );

THE OUTPUT WILL BE

2 1

CLEARLY, THE Linked CLASS IS

WEAK IN TERMS OF WHAT IT

PROVIDES TO USERS. WE WILL

ADDRESS THIS ISSUE SOON.

BUT FIRST, LET’S DEFINE THE

Linked CLASS. AS ITS NAME

SUGGESTS, WE WILL CREATE A

LINKED STRUCTURE. AN ITEM,

TOGETHER WITH A POINTER TO

THE NEXT ITEM WILL BE STORED

IN A struct CALLED Node:

struct Node{ T item; // T is the template parameter Node* next;}; // struct Node

THE ONLY FIELDS IN THE Linked

CLASS ARE

Node* head; // points to first nodelong length; // number of items in the container

SO head IS THE GATEWAY TO THE

ENTIRE CONTAINER!

head item next item next item next

length

re mido NULL

3

HERE ARE THE STRAIGHTFORWARD

DEFINITIONS OF THE DEFAULT

CONSTRUCTOR AND THE size

METHOD:

Linked( ){

head = NULL; length = 0;} // default constructor

long size( ){ return length;} // method size

FOR SIMPLICITY, THE DECLARATION

AND DEFINITION OF THE Linked CLASS

ARE IN THE SAME FILE. NOTE THAT

NO CODE IS GENERATED UNTIL THE

USER DEFINES A PARTICULAR Linked

OBJECT.

TO GET INSPIRATION FOR THE

DEFINITION OF push_front, LET’S SEE

WHAT SHOULD HAPPEN

INTERNALLY WHEN A NEW ITEM IS

INSERTED INTO A Linked

CONTAINER OF THREE ITEMS.

Linked<string> myLinked;

myLinked.push_front (“mi”);myLinked.push_front (“re”);myLinked.push_front (“do”);myLinked.push_front (“ti”);

JUST BEFORE THE FINAL push_front,

WE HAVE

redo mi NULL

myLinked. myLinked.

head length3

THE INSERTION OF “ti” TO myLinked

IS ACCOMPLISHED IN A SEQUENCE

OF STEPS.

BECAUSE EACH ITEM IS STORED IN

A Node, WE START BY CREATING A

NEW NODE:

Node* newHead = new Node;

WE NOW HAVE:

redo mi NULL

myLinked. myLinked.

head lengthnewHead

? ?

3

NEXT, WE STORE newItem, WITH THE

VALUE “ti”, IN THE ITEM FIELD OF

THE Node POINTED TO BY newHead:

newHead -> item = newItem;

THAT GIVES US:

redo mi NULL

myLinked. myLinked.

head lengthnewHead

ti ?

3

BECAUSE “ti” IS TO BE INSERTED AT

THE FRONT OF myLinked, newHead’s

NODE WILL BECOME THE FIRST NODE.

SO THE next FIELD IN THAT NODE

SHOULD POINT TO THE NODE THAT IS

CURRENTLY THE FIRST NODE:

newHead -> next = head;

redo mi NULL

myLinked. myLinked.

head lengthnewHead

ti

3

FINALLY, WE MAKE head POINT TO THE

NEW NODE AND INCREMENT length.

HERE IS THE COMPLETE DEFINITION:

void push_back (const T& item){

Node* newHead = new Node;newHead -> item = newItem;newHead -> next = head;head = newHead;length++;

} // method push_back

redo mi NULL

myLinked. myLinked.

head lengthnewHead

ti

4

EXERCISE: PROVIDE THE

DEFINITION FOR THE FOLLOWING

METHOD IN THE Linked CLASS:

// Postcondition: true has been returned if this// Linked container has no items.// Otherwise, false has been returned.bool empty( );

WHAT ELSE SHOULD THE USER OF

THE Linked CLASS BE ABLE TO DO?

1. GIVEN A Linked CONTAINER OF STUDENTS,

PRINT THE NAME OF EACH STUDENT WHO

MADE THE DEAN’S LIST.

2. GIVEN A Linked CONTAINER OF WORDS,

DETERMINE HOW MANY ARE FOUR-LETTER

WORDS.

3. GIVEN A Linked CONTAINER OF CLUB

MEMBERS, FIND ALL MEMBERS WHO ARE

BEHIND IN DUES PAYMENTS.

IN GENERAL, A USER OF THE Linked

CLASS NEEDS TO BE ABLE TO

ITERATE THROUGH A Linked

CONTAINER.

ITERATING IS EASY FOR THE

DEVELOPER OF THE Linked CLASS

BECAUSE THE DEVELOPER HAS

ACCESS TO THE FIELDS. WE’LL SEE

SEVERAL EXAMPLES OF THIS LATER.

FOR THE SAKE OF USERS, THE Linked

CLASS HAS AN EMBEDDED Iterator

CLASS.

AN ITERATOR IS AN OBJECT THAT

ENABLES A USER TO LOOP THROUGH

A CONTAINER WITHOUT VIOLATING

THE PRINCIPLE OF DATA

ABSTRACTION.

THE Linked AND Iterator CLASSES

TOGETHER MUST PROVIDE A USER

WITH THE ABILITY TO DO AT LEAST

THE FOLLOWING:

1. START AT THE BEGINNING OF THE

CONTAINER;

2. DETERMINE WHEN NO MORE LOOP

ITERATIONS ARE POSSIBLE;

3. ADVANCE TO THE NEXT ITEM IN

THE CONTAINER;

4. RETURN THE ITEM WHERE THE

ITERATOR IS NOW POSITIONED.

THE Linked CLASS ITSELF WILLPROVIDE THE FOLLOWING TWOMETHODS:

// Postcondition: An Iterator positioned at the front of// this Linked container has been// returned.Iterator begin( );

// Postcondition: An Iterator positioned just beyond the// last item in this Linked container has// been returned.Iterator end( );

THE EMBEDDED Iterator CLASSITSELF WILL PROVIDE THEFOLLOWING FOUR OPERATORS:

// Postcondition: true has been returned if itr is// equal to this Iterator. Otherwise, false// has been returned.bool operator== (const Iterator& itr) const;

// Postcondition: true has been returned if itr is not// equal to this Iterator. Otherwise, false// has been returned.bool operator!= (const Iterator& itr) const;

// Precondition: This Iterator is positioned at an item.// Postcondition: The item this Iterator is positioned at// has been returned.T& operator*( ) const;

// Precondition: This Iterator is positioned at an item.// Postcondition: This Iterator has advanced to the// next item unless this Iterator was// positioned at the back item in the// Linked container before this call. In// that case, this Iterator is positioned// just beyond the back item.Iterator operator++ (int); // post-increment operator

NOW A USER CAN ITERATE

THROUGH A Linked CONTAINER:

Linked<string> words;

// Read in the values for words from the input:…int count = 0;Linked<string>::Iterator itr;for (itr = words.begin( ); itr != words.end( ); itr++)

if ((*itr).length( ) == 4)count++;

cout << “There are “ << count << “ 4-letter words.”;

BEFORE WE GET TO THE DETAILS OF

THE Iterator CLASS, HERE IS AN

OUTLINE OF THE ENTIRE Linked

CLASS:

template<class T>class Linked { protected:

struct Node { T item; Node* next; } Node* head; long length;

public: class Iterator {

friend class Linked<T>; protected: public:

} // class Iterator…

} // class Linked

THE Iterator CLASS WILL HAVE ONE

FIELD: A POINTER TO THE NODE

WHERE THE Iterator OBJECT IS

POSITIONED:

Node* nodePtr;

THERE IS A CONSTRUCTOR TO

INITIALIZE THIS POINTER:

// Postcondition: This Iterator has been initialized// through newPtr.Iterator (Node* newPtr){

nodePtr = newPtr;} // constructor with pointer parameter

THIS CONSTRUCTOR IS protected

BECAUSE USERS KNOW NOTHING OF

Node.

THEREFORE, TO ALLOW USERS TO

CONSTRUCT AN Iterator OBJECT,

THERE IS A public DEFAULT

CONSTRUCTOR:

// Postcondition: This Iterator has been constructed.Iterator( ) { }

THE DEFINITIONS OF ==, !=, AND * ARE SIMPLE:

bool operator== (const Iterator& itr) const{

return nodePtr == itr.nodePtr;} // operator==

bool operator!= (const Iterator& itr) const{

return nodePtr != itr.nodePtr;} // operator!=

T& operator*( ) const{

return nodePtr -> item;} // operator*

HERE IS ONE OF SEVERAL WAYS TO

DEFINE operator++ (int), THE POST-

INCREMENT OPERATOR. WE

CONSTRUCT A TEMPORARY

ITERATOR THROUGH nodePtr,

ADVANCE nodePtr TO POINT TO THE

NEXT NODE, AND THEN RETURN THE

TEMPORARY ITERATOR.

Iterator operator++ (int){

Iterator itr (nodePtr);nodePtr = nodePtr -> next;return itr;

} // operator++ (int)

CHAPTER 2 HAS AN ALTERNATE

DEFINITION.

IN ADDITION TO BEING ABLE TO

INSERT AT THE FRONT AND

ITERATING THROUGH A Linked

CONTAINER, A USER SHOULD ALSO

BE ABLE TO DELETE AN ITEM FROM A

Linked CONTAINER.

// Precondition: this Linked container is not empty.// Postcondition: the front item has been deleted// from this Linked container.void pop_front( );

TO AVOID GARBAGE, THE

DEFINITION ALSO DEALLOCATES

THE SPACE OCCUPIED BY THE NODE

THAT CONTAINS THE FRONT ITEM:

void pop_front(){ Node* oldHead = head; head = head -> next; delete oldHead; // deallocates *oldHead --length;} // pop_front

DESTRUCTORS

A DESTRUCTOR IS A METHOD THAT

DEALLOCATES THE SPACE

OCCUPIED BY AN OBJECT:

// Postcondition: This Linked object is empty, and// the space occupied by this Linked// object has been deallocated.~Linked( );

NOTE: NO RETURN TYPE, NO

PARAMETERS!

THE DEFINITION REPEATEDLY

CALLS pop_front( ):

~Linked(){ while (head != NULL) pop_front( );} // destructor

THE DESTRUCTOR FOR AN OBJECT

IS AUTOMATICALLY CALLED WHEN

THE OBJECT GOES OUT-OF-SCOPE,

THAT IS, WHEN THE OBJECT IS NO

LONGER ACCESSIBLE.

FOR EXAMPLE:

void sample( ){

Linked<double> weights;

// Work with weights:…

} // function sample

int main( ){

sample( );return 0;

} // function main

AT THE END OF THE EXECUTION OF

THE FUNCTION sample, THE Linked

OBJECT weights IS OUT-OF-SCOPE,

SO ITS DESTRUCTOR IS

AUTOMATICALLY CALLED.

IF A CLASS DOES NOT EXPLICITLY

DEFINE A DESTRUCTOR, THE

COMPILER WILL AUTOMATICALLY

PROVIDE ONE. THIS DEFAULT

DESTRUCTOR SIMPLY CALLS THE

DESTRUCTOR FOR EACH OBJECT

FIELD.

FOR THE Linked CLASS, SUCH A

DEFAULT DESTRUCTOR WOULD

ACCOMPLISH NOTHING, SINCE THE

Linked CLASS HAS NO OBJECT FIELDS.

SO WE HAD TO EXPLICITLY DEFINE A

DESTRUCTOR FOR THE Linked CLASS

TO AVOID THE POSSIBILITY OF A

MASSIVE MEMORY LEAK.

GENERIC ALGORITHMS

YOU MAY HAVE NOTICED THAT THE

Linked CLASS DOES NOT INCLUDE A

METHOD TO SEARCH FOR A

SPECIFIC ITEM. WHY NOT? BECAUSE

SUCH A FUNCTION IS ALREADY

AVAILABLE!

THE STANDARD TEMPLATE LIBRARY

PROVIDES OVER 100 FUNCTIONS

THAT CAN BE USED WITH

CONTAINERS. THE CONTAINER MAY

BE AN INSTANCE OF THE Linked

CLASS, FOR EXAMPLE, OR AN

ARRAY.

HOW CAN A FUNCTION TO SEARCH A

Linked CONTAINER OF stringS ALSO BE

USED TO SEARCH SOME OTHER

CONTAINER OF doubleS OR AN ARRAY

OF EmployeeS?

THE find FUNCTION IS TEMPLATED:

1. ONE OF THE TEMPLATE PARAMETERS IS FOR

THE ITEM TYPE.

2. THE OTHER TEMPLATE PARAMETER IS FOR

THE KIND OF ITERATOR THAT THE

CONTAINER USES.

3. AN ARRAY POINTER CAN BE SUBSTITUTED

FOR AN ITERATOR.

HAVING A TEMPLATE PARAMETER

FOR THE ITEM TYPE IS

STRAIGHTFORWARD. BUT WHAT KIND

OF ITERATOR DO WE NEED TO SEARCH

A CONTAINER?

THE ONLY OPERATORS THAT SUCH

AN ITERATOR MUST SUPPORT ARE

FOR:

DEREFERENCING: operator*

INCREMENTING: operator++

EQUALITY TESTING: operator== operator!=

AN ITERATOR IN A CLASS THAT

SUPPORTS THOSE OPERATORS IS

CALLED AN INPUT ITERATOR.

NOTE THAT THE Iterator CLASS

EMBEDDED IN THE Linked CLASS

SUPPORTS THOSE OPERATORS.

THE FOLLOWING IMPLEMENTATION,

AND OTHER IMPLEMENTATIONS OF

STANDARD-TEMPLATE-LIBRARY

COMPONENTS IN OTHER SLIDES,

ARE BASED ON THE ORIGINAL

IMPLEMENTATION, FROM HEWLETT-

PACKARD RESEARCH LAB.

Copyright (c) 1994Hewlett-Packard Company

Permission to use, copy, modify, distribute and sell thissoftware and its documentation for any purpose ishereby granted without fee, provided that the abovecopyright notice appear in all copies and that both thatcopyright notice and this permission notice appear insupporting documentation. Hewlett-Packard Companymakes no representations about the suitability of thissoftware for any purpose. It is provided "as is" withoutexpress or implied warranty.

HERE, FROM algo.h, IS THE HEWLETT-

PACKARD DEFINITION OF find:// Postcondition: If there is an item in the range from// first (inclusive) to last (exclusive) that// equals value, an iterator positioned at// such an item has been returned.// Otherwise, an iterator positioned at// last has been returned.template <class InputIterator, class T>InputIterator find(InputIterator first, InputIterator last,

const T& value){ while (first != last && *first != value) ++first; return first;}

BECAUSE ARRAY POINTERS ALSO

SUPPORT OPERATORS *, ++, AND !=,

THE find FUNCTION CAN ALSO

SEARCH AN ARRAY. THE

FOLLOWING PROGRAM SEGMENT

SEARCHES A Linked CONTAINER OF

string ITEMS AND AN ARRAY OF int

ITEMS.

Linked<string> words;

words.push_front ("mellow");words.push_front ("placid");words.push_front ("serene");Linked<string>::Iterator itr;itr = find (words.begin( ), words.end( ), "placid");if (itr == words.end( )) cout << "word not found" << endl;else cout << "word found" << endl;

int scores [5];

for (int i = 0; i < 5; i++) scores [i] = 20 * i;if (find (scores, scores + 5, 35) == scores + 5) cout << "score not found" << endl;else cout << "score found" << endl;

TEMPLATE FUNCTIONS, ALSO

CALLED GENERIC ALGORITHMS,

CONSTITUTE ONE OF THE THREE

MAJOR COMPONENTS OF THE

STANDARD TEMPLATE LIBRARY.

THE OTHER TWO ESSENTIALS ARE

CONTAINER CLASSES AND

ITERATORS. NOTICE THE

CONNECTION: GENERIC

ALGORITHMS OPERATE ON

CONTAINERS THROUGH ITERATORS.

EXERCISE: PROVIDE A DEFINITION OF THE

FOLLOWING GENERIC ALGORITHM:

// Postcondition: true has been returned if for each// iterator itr in the range from first1// (inclusive) to last1 (exclusive),// *itr = *(first2 + (itr – first1)).// Otherwise, false has been returned.template <class InputIterator1, class InputIterator2>bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);

HINT: DEFINE

InputIterator itr1 = first1, itr2 = first2;