HERE IS THE BASIC IDEA:
-
Upload
hyatt-suarez -
Category
Documents
-
view
18 -
download
2
description
Transcript of HERE IS THE BASIC IDEA:
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;