1. Popping Items Off a Stack Using a Function Lesson xx
In the last module, we learned how to build a dynamic stack and pop items off in main(). This module is about popping items using a function.

2. Objectives Popping items off a stack in a function
Passing a pointer to a function
Returning a pointer from a function
Our goal in this presentation is to show you how to pop an item off the stack in a function. As an added attraction we will learn about passing pointers to a function and returning a pointer from a function.

3. Definition of Pop
Popping means we take the contents of the first node and store it somewhere for processing.
When you pop something off the stack, it implies that the 1st node is to be deleted
The second node is then the new head of the list.
Popping means we take the contents of the first node and store it somewhere for processing. When you pop something off the stack, it implies that the 1st node is to be deleted. The second node is then the new head of the list.

4. Program Definition
Write a program that will build a stack. When the user enters a number, create a node and push it onto the top of the stack. The user may enter as many numbers as they wish. The user signifies the end of input by typing the letter ‘s’ for “stop.
After the stack is built, pop the first item of the stack into x using a function.
Now, let’s write a program to build a stack. When the user enters a number, create a node and push it onto the top of the stack. The user may enter as many numbers as they wish. The user signifies the end of input by typing the letter ‘s’ for “stop”. After the stack is built pop the first item of the stack into x.

5. Listing of Popping Program Part 1
#include <iostream> using std::cin; using std::cout; using std::endl;
#include <cstdlib>
struct entry {   int value;   entry* next; };
void printList(const entry*); // prototype
entry* pop (entry * h);
int main() {   char str[15];
  entry* head = 0; // initially empty list
  while(1) // create nodes   {     cout << "enter a value (s = stop) “;     cin >> str;     if (str[0] == 's')       break;
    entry* temp = new entry; // dynamic memory allocation     temp->value = atoi(str);     temp->next = head; // put new node at front of list     head = temp; // denote new node as new head of list   }
  printList(head); // print list
This is the code for the 1st part of the program which builds the stack. The while (1) loop allows the user to create a stack that is any size. When the user presses the ‘s’ key, input is terminated. It is the same as the previous module on popping except that we have a prototype for our pop() function. It is highlighted for you in red.

6. Listing of Popping Program Part 2
// remove the head of the list (popping) int x;
head = pop (head, &x); // call to the pop function printList(head); // print after popping
return 0; }
entry* pop (entry* h, int * a) { if (h)   { *a = h->value; //indirectly put value in x     entry* n = h->next;     delete h;     h = n;   }   return h; }
void printList(const entry* h) {   for (const entry* p = h; p; p = p->next)     cout << p->value << endl; }
This is the 2nd part of the code to pop the 1st node into x. The call to function pop() is highlighted in red and so is the listing of function pop(). Afterwards, we print the stack to verify that the 1st node was popped off. Let’s go through the program now.

7. Stack Building Code Output from printList
char str[15];
  entry* head = 0; // initially empty list
  while(1) // create nodes   {     cout << "enter a value (s = stop) “;     cin >> str;     if (str[0] == 's')       break;
    entry* temp = new entry; // dynamic memory allocation     temp->value = atoi(str);     temp->next = head; // put new node at front of list     head = temp; // denote new node as new head of list   }
f3c
head
(76c)
2fe 55 44
(f3c)
4af
88b 33
(4af)
76c 22 11
(2fe)
(88b)
We have listed the stack building code for you. The picture shows you the stack after the user has entered 5 #s. At the bottom, we have listed the output of the printList() function. All this code was explained in the previous module if you need a review.
Output from printList
node address: f3c value next 2fe
node address: 2fe value next 4af
node address: 4af value next b
node address: 88b value next c
node address: 76c value next 0

8. Call to Function Pop f3c head (76c) 2fe 55 44 (f3c) 4af 88b 33 (4af)
int x;
head = pop (head, &x); // call to the pop function
entry* pop (entry* h, int * a)
f3c
head
(76c)
2fe 55 44
(f3c)
4af
88b 33
(4af)
76c 22 11
(2fe)
(88b)
Here is the picture when you call function pop(). Head is passed into the variable h and the address of x is passed into the pointer a. h points to the node to be popped and a points to x.
55d h
f3c x a
(55d)

9. Inside Function Pop( ) Indirectly Put Top of Stack in x
entry* pop (entry* h, int * a) { if (h)   { *a = h->value; //indirectly put value in x     entry* n = h->next;     delete h;     h = n;   }   return h; }
f3c
head
(76c)
2fe 55 44
(f3c)
4af
88b 33
(4af)
76c 22 11
(2fe)
(88b) x
55d a
(55d)
The 1st statement in the pop function is if (h). Here we are making sure that the stack has something in it. We don’t want pop off something if the list is empty. The 1st statement inside the if is: *a = h->value; This is how we indirectly store the contents of the first node in x. Look at it this way, *a = h->value means: in the variable pointed to by a, store what is in h->value. a is pointing to x and h->value is 55, therefore, the # 55 is stored in to x. h

10. Inside Function Pop( ) Point to 2nd Node, Delete 1st Node
(1) *a = h->value; (2)    entry* n = h->next; (3)    delete h; (4)    h = n;
f3c
head
2fe
(76c) 55 44
(f3c)
4af
88b 33
(4af)
76c 22 11
(2fe)
(88b) 2 n
Now, that we have the contents of the 1st node in x, consider this step 1, let’s look at the remaining code inside of the if . For step 2, we need to set up a pointer called n and make it point to the second node. This is accomplished with the statement: entry*n = h->next; In step 3, we need to release the memory occupied by the 1st node with delete h;. 3
f3c 55
55d h x a 1
(55d)

11. Inside Function Pop( ) Make h Point to 2nd Node
(1) *a = h->value; (2)    entry* n = h->next; (3)    delete h; (4)    h = n;
head 2
f3c
2fe n
(f3c)
(2fe)
(4af)
(88b)
(76c) 44
4af 33
88b 22
76c 11
After we have completed steps 1-3 the first node is gone. For step 4, we make h point to the second node with the statement h = n; Now, h has the address of the 2nd node which is 2fe. As you can see from our picture, back in main() head is pointing to a non-existent node because we deleted it in step 3. Not to worry. 4
2fe 55
55d h x a 1
(55d)

12. Returning a Pointer From Pop( )
(5) return h;
2fe
head
(76c) 44
4af
88b 33
(4af)
76c 22 11
(2fe)
(88b) 2 n 5
The very last statement of the pop function is: return h; This will take what is in h and put it in head in main(). We have labeled this as step 5. In our picture, head is pointing to the 2nd node. This is an example of returning a pointer from a function 4
2fe 55
55d h x a 1
(55d)

13. After Call to Pop( ) Function
2fe
head
(76c) 44
4af
88b 33
(4af)
76c 22 11
(2fe)
(88b)
When you exit function pop(), all the local variable disappear and your picture will look as follows back in main() : head will point to the original 2nd node and x will contain the # 55. The red indicates the operations that happened in function pup. There you have popping the 1st node into x. The last operation that we performed in this program is to call the printList() function to verify that the first node was indeed popped off. 55 x
(55d)

14. Summary Popping items off a stack in a function
Passing a pointer to a function
Returning a pointer from a function
In this presentation, we reviewed building a dynamic stack. We also learned about popping items off a stack in a function. As a side benefit, we saw how pointers are passed to functions and a use for returning a pointer. In the next modules we’ll put these data structures such as queues and stacks to use.