Chapter 11 Pointers Part 3 (Putting it all together) Student Learning Outcomes (SLOs)

Transcription

1 Chapter 11 Pointers Part 3 (Putting it all together) Student Learning Outcomes (SLOs) a. Create a hierarchy diagram of link list operations. b. Edit a record in a linked list. c. Describe the use of the delete operator. d. Delete a record in a linked list. Rationale and Preliminary Information At thisw point we have the majority of the infrormation to puttogether a meaningful program theat relies on dynamic memory allocation ( that is allocating the required memory during the execfution of the program) with the possible exception of file access (next chapter). Program 11.1 uses many of the programming modules presented in previous chapters (chapters 2 through 10) in the context of a single program. You will notice that as with the array based program, the program relies heavily on modular programming. This is because by creating individual programming modules (functions) we can more easily reuse the programming units, often with minor changes or no changes at all. Because there are so many pieces, it is recommended that we revisit the hierarchy diagram to provide an over view as to how the elements of the program fit together. The following diagram represents the hierarchy chart of the program to be. < Insert hierarchy 12-1 chart > In the hierarchy chart remember that process generally goes left to right and top to bottom. Sence we can not (at this point) control user input sequence, there is no guarentee that the sequence will be followed, but this is the nominal flow. Notice that there are a number

2 of calls indicated to screenheading() and pagecontinue(). Each of these is a single function but it is accessed from numerous functions (they are not written multiple times!!). Often hierarchy charts will combine data flow and other characteristics but this will do for our use. Here we do include the menu options that trigger the various menu operation sequences. Two additional modules have been implemented in this version of the Employee Tracking Program : employeeedit() and employeedelete(). The employeeedit() module is based on the search module in that the search module is called to find the employee to be edited the beginning address ( if found ) is sent to the edit() function. The employeedelete() uses a new concept that of a trailing pointer. This will be discussed below. One operator is introduced in this program the delete operator. The delete operator has an essentially reciprical function to the new operator. It de allocates memory pointed to by a pointer variable. In a real-time program we would have to deallocate any memory that is allocated and assigned to a pointer variable. This is because when memory is allocated within a function and the address assigned to a pointer variable only the variable is deallocated during the exit of the function NOT the allocation that is pointed to. Load and execute program Program 11.1 is based on the array implementation program, program 8.1. Program 11.1 is highly modularized and reuses several of the functions developed in earlier programs. Blow by Blow Description (Prog_11.1) The significant additions to the program are the modularization through the use of functions that receive and return pointers and the addition of the ability to edit and delete records (the last two function definitions of Prog_11.1). This prresentation will focus on the edit() and deleteemployee() functions as examples

3 Before actually getting into a blow-by-blow analysis, generally look at the function headings and compare them to the prototypes at the top of the program. Notice that the prototypes follow our same rule of simply copying the function heading and pasting into the protype area. As before the prototypes only require the data types (with the pointer notation) and not the parameter names. The parameter names have been removed from a few of the prototypes as an illustration. 1. Find the mainmenu() function above. Now look down into the switch() for the edit option. You will see the following code case 'E': case 'e': found" ); // New function cout << "Edit option" << endl; found = lnamesearch( s ); if(!found ) screenheading( "Employee NOT } else break; for( int i = 0; i < 18; i++ ) cout << endl; pagecontinue(); edit(found); The first function call is to the lnamesearch() module. Here we are sending the address to the beginning of the linked list. That module prompts for a string (last name) that is to be located. If the string is located, the beginning address of that structure is returned to the found variable. If the value is not found a NULL is returned to the variable. If the string is not found (!found ) then the Employee NOT found message is displayed and the edit option is terminated. If the string is found then the edit() function is

4 called with the beginning address of the structure in which the string was found. 2. Now lets look at the edit() module. You will notice that module takes the form of a standard menu. Options are displayed (for selecting a data member to edit) along with a quit option, a prompt to make a selection, and a switch() statement within which the desired selection is executed. All of this is embedded in a do while loop which will continue to execute until the user selects the quit option. It should be noted that each time the loop executes the new data will be shown as the replacement for the old data. In this process we are actually editing the ORIGINAL linked list. 3. Now lets look at the deleteemployee() module. This is where we make use of the delete operator. employee* deleteemployee( employee *item, employee *s) employee *p = s; employee *trailer = NULL; screenheading( "Delete Employee Record" ); pagecontinue( ); if( item == p) s = s-> next; delete item; } else p = s; while( p && (p!= item) ) trailer = p ; p = p -> next; } if( p )

5 } } trailer -> next = p -> next; delete p; return s; We send two pointers into this module the beginning of the list and the address of the record to be deleted (which was located using the lnamesearch() function). Within the function s is the pointer to the beginning of the list and item to the record to be removed. We are returning a copy of the pointer that is pointing to the beginning of the list. Why you ask?? Because the first structure might be the one to delete. If it is, the beginning of the list will be a different memory location than the one that was sent to the function. There are two situations that might occur in deleting records from the list the first is when the record to be deleted is at the top of the list ( this is the if() option ). In this case we make a copy of the address of the first structure, increment the list pointer to the next item, and delete the beginning structure. The second situation occurs in all other cases (this is the while() ). Here we initialize a trailing pointer then increment the pointer to the next structure. trailer = p ; p = p -> next; In this case I use a pointer variable named trailer (seemed appropriate). I assign it a copy of p. Then I incrememt p ( p = p -> next ). The trailing pointer is the critical one because it contains the address of the structure (or class) immediately preceeding the one to be deleted. It will be the key to linking the beginning portion of the list the the portion following the element to be deleted. We have to link the first part of the list to the last part of

6 the list BEFORE we delete the structure. The link and deletion follows trailer -> next = p -> next; // links the front part // of the list to the back part of the list delete p; // removes the desired record The last thing we do is to return the beginning of the list (as modified) to the calling programming. Programming issues 1. The first issue we come to as programmers is that of organization. This is where the hirearchy chart and the IPO charts really shine. The hierarchy chart is your road map indicating the operational sequence of your programming project. Each of the different modules in your hierarchy chart should have an associated IPO chart. Remember that not all functions will have explicit input or process. But it is good practice to consider input for all modules. Input might be in the form of an input function (ie. cin, getline(), etc.) or input might be in the form of parameters in the function headings. Some modules may not process the data in terms of actual manipulation. They may simply provide formatting for the data they receive during an output process. Output could be in the form of outputting something to the console, returning a value, outputting (editing) data in an existing record, or output to an external file. In any event the use of an IPO chart will remind you to consider each of these aspects as you develop each of your functions.

7 2. We have encountered the delete operator. The delete operator deallocates memory references by a pointer variable. The syntax is as follows delete pointer_var; You will notice that delete and new are reserved words (typically blue in the MS Visual editor). As such they have a special meaning to the compiler. It is necessary to use delete to deallocate any memory that has been allocated and is pointed to by a pointer variable. Failure to do so may result in unusable memory in your computer (a memory leak) until such time you re-boot your machine. 3. The final programming technique that we encountered with this program is that of a trailing pointer. Almost by definition it is a pointer that references the previous structure. We have seen the standard pointer incrementation in a list. For example ptr = ptr -> next. Now we are combining this with a pointer variable that is initialized prior to the incrementation. Your turn Modify the programs above to incorporate searching operations, editing operations, and item removal (deletions). Once again insert your functions one at a time, get them working then move to the next. Try creating operations for multiple data members ( Last Name and address or zip code, etc. ). This will probable involve parallel functions that is two function doing basically the same operation but with different data members. The following is an example of parallel functions. One of the functions is the lnamesearch() from above and the other is essentally the same function but searching for an address.

8 lnamesearch() employee* lnamesearch( employee *s) // This is a "Key value" search. It will catch only the first // occurance of the value to find. string srchname = "XXXX"; screenheading( "LAST NAME Search Screen" ); cout << endl << endl << endl; cout << "Enter a LAST NAME to locate: "; getline( cin, srchname ); while ( ( s ) && ( srchname!= s->l_name ) ) s = s->next; // Increment the pointer instead of the subscript return s; //Sending a copy of the address at which the found // value is located (s will be NULL if not found. } //End of employee* lnamesearch( employee s[], int numempl)

9 addrsearch() employee* addrsearch( employee *s) // This is a "Key value" search. It will catch only the first // occurance of the value to find. string srchname = "XXXX"; screenheading( "ADDRESS Search Screen" ); cout << endl << endl << endl; cout << "Enter a ADDRESS to locate: "; getline( cin, srchname ); while ( ( s ) && ( srchname!= s->addr ) ) s = s->next; // Increment the pointer instead of the subscript return s; //Sending a copy of the address at which the found // value is located (s will be NULL if not found. } //End of employee* lnamesearch( employee s[], int numempl) The changes are highlighted. That is all there usually is to do. Sometimes with judicious use of if() you can combine the functions ( but that is fluf on top of the cake). Be sure to add the prototype and the call and you are in business.