here is the basic idea:
DESCRIPTION
HERE IS THE BASIC IDEA:. do. re. mi. myLinked. myLinked. head length. 3. NULL. do. re. mi. myLinked. myLinked. head length. newHead. 3. ?. ?. do. re. mi. NULL. myLinked. myLinked. - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/1.jpg)
CHAPTER 2
STORAGE STRUCTURES
FOR
CONTAINER CLASSES
![Page 2: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/2.jpg)
A DYNAMIC VARIABLE IS ONE
THAT IS CREATED AND DESTROYED
BY THE PROGRAMMER DURING
EXECUTION. THIS CAN SAVE A LOT
OF SPACE IN MEMORY.
![Page 3: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/3.jpg)
DYNAMIC VARIABLES ARE STORED
IN THE HEAP, A LARGE AREA OF
MEMORY.
![Page 4: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/4.jpg)
DYNAMIC VARIABLES ARE NEVER
ACCESSED DIRECTLY. THEY ARE
ACCESSED THROUGH POINTER
VARIABLES.
![Page 5: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/5.jpg)
A POINTER VARIABLE
CONTAINS THE ADDRESS OF A
VARIABLE (USUALLY, A DYNAMIC
VARIABLE).
![Page 6: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/6.jpg)
A POINTER TYPE IS A TYPE
FOLLOWED BY AN ASTERISK:
string* sPtr;
HERE, sPtr IS A POINTER VARIABLE,
SPECIFICALLY, A POINTER TO A
STRING.
![Page 7: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/7.jpg)
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.
![Page 8: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/8.jpg)
sPtr ?
![Page 9: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/9.jpg)
TO ACCESS THE DYNAMIC VARIABLE,
WE DEREFERENCE THE POINTER
VARIABLE. THE DEREFERENCE
OPERATOR, ‘*’, IS PLACED
IN FRONT OF
THE POINTER VARIABLE: *sPtr
![Page 10: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/10.jpg)
THE DYNAMIC VARIABLE CAN NOW
BE TREATED AS AN ORDINARY string
VARIABLE. FOR EXAMPLE,
*sPtr = “serene”; // note ‘*’ to left of sPtr
![Page 11: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/11.jpg)
sPtrserene
![Page 12: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/12.jpg)
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
![Page 13: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/13.jpg)
IN THE EXPRESSION
(*sPtr).length() <= 6
PARENTHESES AROUND *sPtr ARE
NEEDED: THE MEMBER-SELECTION
OPERATOR (THE DOT) HAS HIGHER
PRECEDENCE THAN THE
DEREFERENCE OPERATOR.
![Page 14: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/14.jpg)
ALTERNATIVE NOTATION: THE
DEREFERENCE-AND-SELECT
OPERATOR IS ->
sPtr -> length() <= 6
THIS IS EQUIVALENT TO
(*sPtr).length() <= 6
![Page 15: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/15.jpg)
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.
![Page 16: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/16.jpg)
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
![Page 17: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/17.jpg)
THEN WE CAN CONSTRUCT A
SEQUENCE OF NODES LIKE LINKS IN
A CHAIN:
data next data next data next
91.7 84.532.6
![Page 18: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/18.jpg)
ARRAYS
![Page 19: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/19.jpg)
string* words;
HERE, words CAN BE A POINTER
TO EITHER A SINGLE STRING OR
TO AN ARRAY OF STRINGS.
![Page 20: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/20.jpg)
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.
![Page 21: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/21.jpg)
words
![Page 22: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/22.jpg)
THE INDEX OPERATOR, operator[ ], IS
USED TO REFERENCE THE
INDIVIDUAL ITEMS:
words [1] = “tranquil”;
THIS IS EQUIVALENT TO
*(words + 1) = “tranquil”;
![Page 23: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/23.jpg)
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!
![Page 24: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/24.jpg)
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];
![Page 25: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/25.jpg)
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.
![Page 26: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/26.jpg)
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.
![Page 27: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/27.jpg)
capacity *= 2; // double the capacitystring* temp = new string [capacity];
for (int i = 0; i < capacity / 2; i++) temp [i] = words [i];
words = temp;
![Page 28: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/28.jpg)
words
temp
Thesearetheoriginal
items
![Page 29: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/29.jpg)
TO DEALLOCATE THE SPACE FOR
AN ARRAY, USE AN EMPTY INDEX:
delete[ ] words;
![Page 30: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/30.jpg)
CONTAINER
CLASSES
![Page 31: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/31.jpg)
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.
![Page 32: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/32.jpg)
THERE ARE TWO WIDELY USED
KINDS OF STRUCTURES FOR
STORING THE ITEMS IN A
CONTAINER OBJECT: AN ARRAY AND
A LINKED STRUCTURE.
![Page 33: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/33.jpg)
IN THE FIRST STRUCTURE, ONE OF
THE FIELDS IN THE CLASS IS AN
ARRAY, AND THE ITEMS ARE
STORED IN THIS ARRAY.
![Page 34: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/34.jpg)
ADVANTAGE: ALLOWS RANDOM-
ACCESS OF ITEMS.
![Page 35: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/35.jpg)
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.
![Page 36: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/36.jpg)
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.
![Page 37: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/37.jpg)
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.
![Page 38: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/38.jpg)
do re mi
HERE IS THE BASIC IDEA:
![Page 39: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/39.jpg)
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?
![Page 40: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/40.jpg)
SPECIFICALLY, WHAT TYPE OF
ITEMS WILL THE Linked CLASS
HANDLE?
![Page 41: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/41.jpg)
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.
![Page 42: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/42.jpg)
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.
![Page 43: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/43.jpg)
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;
![Page 44: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/44.jpg)
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.
![Page 45: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/45.jpg)
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.
![Page 46: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/46.jpg)
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.
![Page 47: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/47.jpg)
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.
![Page 48: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/48.jpg)
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);
![Page 49: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/49.jpg)
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( );
![Page 50: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/50.jpg)
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.
![Page 51: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/51.jpg)
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:
![Page 52: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/52.jpg)
struct Node{ T item; // T is the template parameter Node* next;}; // struct Node
![Page 53: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/53.jpg)
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!
![Page 54: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/54.jpg)
head item next item next item next
length
re mido NULL
3
![Page 55: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/55.jpg)
HERE ARE THE STRAIGHTFORWARD
DEFINITIONS OF THE DEFAULT
CONSTRUCTOR AND THE size
METHOD:
![Page 56: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/56.jpg)
Linked( ){
head = NULL; length = 0;} // default constructor
long size( ){ return length;} // method size
![Page 57: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/57.jpg)
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.
![Page 58: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/58.jpg)
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.
![Page 59: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/59.jpg)
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
![Page 60: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/60.jpg)
redo mi NULL
myLinked. myLinked.
head length3
![Page 61: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/61.jpg)
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:
![Page 62: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/62.jpg)
Node* newHead = new Node;
WE NOW HAVE:
![Page 63: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/63.jpg)
redo mi NULL
myLinked. myLinked.
head lengthnewHead
? ?
3
![Page 64: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/64.jpg)
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:
![Page 65: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/65.jpg)
redo mi NULL
myLinked. myLinked.
head lengthnewHead
ti ?
3
![Page 66: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/66.jpg)
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;
![Page 67: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/67.jpg)
redo mi NULL
myLinked. myLinked.
head lengthnewHead
ti
3
![Page 68: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/68.jpg)
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
![Page 69: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/69.jpg)
redo mi NULL
myLinked. myLinked.
head lengthnewHead
ti
4
![Page 70: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/70.jpg)
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( );
![Page 71: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/71.jpg)
WHAT ELSE SHOULD THE USER OF
THE Linked CLASS BE ABLE TO DO?
![Page 72: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/72.jpg)
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.
![Page 73: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/73.jpg)
IN GENERAL, A USER OF THE Linked
CLASS NEEDS TO BE ABLE TO
ITERATE THROUGH A Linked
CONTAINER.
![Page 74: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/74.jpg)
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.
![Page 75: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/75.jpg)
FOR THE SAKE OF USERS, THE Linked
CLASS HAS AN EMBEDDED Iterator
CLASS.
![Page 76: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/76.jpg)
AN ITERATOR IS AN OBJECT THAT
ENABLES A USER TO LOOP THROUGH
A CONTAINER WITHOUT VIOLATING
THE PRINCIPLE OF DATA
ABSTRACTION.
![Page 77: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/77.jpg)
THE Linked AND Iterator CLASSES
TOGETHER MUST PROVIDE A USER
WITH THE ABILITY TO DO AT LEAST
THE FOLLOWING:
![Page 78: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/78.jpg)
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.
![Page 79: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/79.jpg)
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( );
![Page 80: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/80.jpg)
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;
![Page 81: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/81.jpg)
// 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
![Page 82: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/82.jpg)
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.”;
![Page 83: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/83.jpg)
BEFORE WE GET TO THE DETAILS OF
THE Iterator CLASS, HERE IS AN
OUTLINE OF THE ENTIRE Linked
CLASS:
![Page 84: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/84.jpg)
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
![Page 85: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/85.jpg)
THE Iterator CLASS WILL HAVE ONE
FIELD: A POINTER TO THE NODE
WHERE THE Iterator OBJECT IS
POSITIONED:
Node* nodePtr;
![Page 86: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/86.jpg)
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.
![Page 87: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/87.jpg)
THEREFORE, TO ALLOW USERS TO
CONSTRUCT AN Iterator OBJECT,
THERE IS A public DEFAULT
CONSTRUCTOR:
// Postcondition: This Iterator has been constructed.Iterator( ) { }
![Page 88: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/88.jpg)
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*
![Page 89: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/89.jpg)
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.
![Page 90: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/90.jpg)
Iterator operator++ (int){
Iterator itr (nodePtr);nodePtr = nodePtr -> next;return itr;
} // operator++ (int)
CHAPTER 2 HAS AN ALTERNATE
DEFINITION.
![Page 91: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/91.jpg)
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.
![Page 92: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/92.jpg)
// 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:
![Page 93: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/93.jpg)
void pop_front(){ Node* oldHead = head; head = head -> next; delete oldHead; // deallocates *oldHead --length;} // pop_front
![Page 94: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/94.jpg)
DESTRUCTORS
![Page 95: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/95.jpg)
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!
![Page 96: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/96.jpg)
THE DEFINITION REPEATEDLY
CALLS pop_front( ):
~Linked(){ while (head != NULL) pop_front( );} // destructor
![Page 97: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/97.jpg)
THE DESTRUCTOR FOR AN OBJECT
IS AUTOMATICALLY CALLED WHEN
THE OBJECT GOES OUT-OF-SCOPE,
THAT IS, WHEN THE OBJECT IS NO
LONGER ACCESSIBLE.
![Page 98: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/98.jpg)
FOR EXAMPLE:
void sample( ){
Linked<double> weights;
// Work with weights:…
} // function sample
int main( ){
sample( );return 0;
} // function main
![Page 99: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/99.jpg)
AT THE END OF THE EXECUTION OF
THE FUNCTION sample, THE Linked
OBJECT weights IS OUT-OF-SCOPE,
SO ITS DESTRUCTOR IS
AUTOMATICALLY CALLED.
![Page 100: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/100.jpg)
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.
![Page 101: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/101.jpg)
FOR THE Linked CLASS, SUCH A
DEFAULT DESTRUCTOR WOULD
ACCOMPLISH NOTHING, SINCE THE
Linked CLASS HAS NO OBJECT FIELDS.
![Page 102: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/102.jpg)
SO WE HAD TO EXPLICITLY DEFINE A
DESTRUCTOR FOR THE Linked CLASS
TO AVOID THE POSSIBILITY OF A
MASSIVE MEMORY LEAK.
![Page 103: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/103.jpg)
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!
![Page 104: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/104.jpg)
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.
![Page 105: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/105.jpg)
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?
![Page 106: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/106.jpg)
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.
![Page 107: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/107.jpg)
HAVING A TEMPLATE PARAMETER
FOR THE ITEM TYPE IS
STRAIGHTFORWARD. BUT WHAT KIND
OF ITERATOR DO WE NEED TO SEARCH
A CONTAINER?
![Page 108: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/108.jpg)
THE ONLY OPERATORS THAT SUCH
AN ITERATOR MUST SUPPORT ARE
FOR:
DEREFERENCING: operator*
INCREMENTING: operator++
EQUALITY TESTING: operator== operator!=
![Page 109: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/109.jpg)
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.
![Page 110: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/110.jpg)
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.
![Page 111: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/111.jpg)
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.
![Page 112: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/112.jpg)
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;}
![Page 113: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/113.jpg)
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.
![Page 114: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/114.jpg)
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;
![Page 115: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/115.jpg)
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;
![Page 116: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/116.jpg)
TEMPLATE FUNCTIONS, ALSO
CALLED GENERIC ALGORITHMS,
CONSTITUTE ONE OF THE THREE
MAJOR COMPONENTS OF THE
STANDARD TEMPLATE LIBRARY.
![Page 117: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/117.jpg)
THE OTHER TWO ESSENTIALS ARE
CONTAINER CLASSES AND
ITERATORS. NOTICE THE
CONNECTION: GENERIC
ALGORITHMS OPERATE ON
CONTAINERS THROUGH ITERATORS.
![Page 118: HERE IS THE BASIC IDEA:](https://reader036.vdocuments.us/reader036/viewer/2022062517/5681325c550346895d98edc5/html5/thumbnails/118.jpg)
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;