Need some help to write a loop to get this output below

[Bopaki]

6929
372
1734
1767
1732
Process returned 0 (0x0)   execution time : 2.387 s
Press any key to continue.

//Header File linkedStack.h


#ifndef H_StackType
#define H_StackType

#include <iostream>
#include <cassert>

using namespace std;

//Definition of the node
template <class Type>
struct nodeType
{
	Type info;
	nodeType<Type> *link;
};

template<class Type>
class linkedStackType
{
public:
    const linkedStackType<Type>& operator=
                                (const linkedStackType<Type>&);
     	//Overload the assignment operator.
    void initializeStack();
	//Function to initialize the stack to an empty state.
	//Postcondition: The stack elements are removed;
 	//               stackTop = NULL.
    bool isEmptyStack();
	//Function to determine whether the stack is empty.
 	//Postcondition: Returns true if the stack is empty;
	//               otherwise, returns false.
    bool isFullStack();
	//Function to determine whether the stack is full;
	//Postcondition: Returns false.
    void push(const Type& newItem);
	//Function to add newItem to the stack.
	//Precondition: The stack exists and is not full.
	//Postcondition: The stack is changed and newItem
	//               is added to the top of stack.

    Type top();
	//Function to return the top element of the stack.
	//Precondition: The stack exists and is not empty.
 	//Postcondition: If the stack is empty, the program
 	//               terminates; otherwise, the top element
	//               of the stack is returned.

    void pop();
	//Function to remove the top element of the stack.
	//Precondition: The stack exists and is not empty.
	//Postcondition: The stack is changed and the top element
      //               is removed from the stack.

    void destroyStack();
	//Function to remove all the elements of the stack,
      //leaving the stack in an empty state.
 	//Postcondition: stackTop = NULL

    linkedStackType();
   	//default constructor
  	//Postcondition: stackTop = NULL
    linkedStackType(const linkedStackType<Type>& otherStack);
  	//copy constructor
    ~linkedStackType();
	//destructor
	  //All the elements of the stack are removed from the stack.

private:
    nodeType<Type> *stackTop; //pointer to the stack

    void copyStack(const linkedStackType<Type>& otherStack);
      //Function to make a copy of otherStack.
 	//Postcondition: A copy of otherStack is created and
 	//               assigned to this stack.
 	int maxStackSize;
};


template<class Type> //default constructor
linkedStackType<Type>::linkedStackType()
{
	stackTop = NULL;
}

template<class Type>
void linkedStackType<Type>::destroyStack()
{
	nodeType<Type> *temp; //pointer to delete the node

	while(stackTop != NULL)  //while there are elements in the stack
	{
	   temp = stackTop;      //set temp to point to the current node
	   stackTop = stackTop->link; //advance stackTop to the next node
	   delete temp;     //deallocate memory occupied by temp
	}
}// end destroyStack

template<class Type>
voidlinkedStackType<Type>:: initializeStack()
{
    destroyStack();
}

template<class Type>
bool linkedStackType<Type>::isEmptyStack()
{
	return(stackTop == NULL);
}

template<class Type>
bool linkedStackType<Type>:: isFullStack()
{
   return false;
}

template<class Type>
void linkedStackType<Type>::push(const Type& newElement)
{
   nodeType<Type> *newNode; //pointer to create the new node

   newNode = new nodeType<Type>; //create the node
   assert(newNode != NULL);

   newNode->info = newElement;   //store newElement in the node
   newNode->link = stackTop;     //insert newNode before stackTop
   stackTop = newNode;          //set stackTop to point to the top node
} //end push


template<class Type>
Type linkedStackType<Type>::top()
{
	assert(stackTop != NULL);	//if stack is empty,
								//terminate the program
   	return stackTop->info; //return the top element
}//end top

template<class Type>
void linkedStackType<Type>::pop()
{
   nodeType<Type> *temp;       //pointer to deallocate memory

   if(stackTop != NULL)
   {
   		temp = stackTop;            //set temp to point to the top node
   		stackTop = stackTop->link;  //advance stackTop to the next node
   		delete temp;	            //delete the top node
   }
   else
		cerr<<"Cannot remove from an empty stack."<<endl;
}//end pop

template<class Type>
void linkedStackType<Type>::copyStack(const linkedStackType<Type>& otherStack)
{
	//cout<<"See Programming Exercise 1"<<endl;
    //delete [] stackTop;

} // end copyStack

template<class Type>   //copy constructor
linkedStackType<Type>::linkedStackType(
                       const linkedStackType<Type>& otherStack)
{
	//cout<<"See Programming Exercise 1"<<endl;
       if(otherStack.stackTop == NULL)
           stackTop = NULL;
       else
       {
           linkedStackType temp = otherStack.top;
           linkedStackType end;
           end = new linkedStackType;
           end->info = temp->info;
           top = end;
           //First node created and filled with data.
           //New nodes are now added AFTER this first node
           temp = temp->link;
           while (temp != NULL)
           {
               end->link = new linkedStackType;
               end = end->link;
               end->info = temp->info;
               temp = temp->link;
           }
           end->link = NULL;
       }
}//end copy constructor


template<class Type> //destructor
linkedStackType<Type>::~linkedStackType()
{
	// cout<<"See Programming Exercise 1"<<endl;
	delete [] stackTop;  //deallocate memoty occupied by the array
}//end destructor
template<class Type>   //overloading the assignment operator
const linkedStackType<Type>& linkedStackType<Type>::operator=
    			  (const linkedStackType<Type>& otherStack)
{

	//cout<<"See Programming Exercise 1"<<endl;
 	if(this != &otherStack)
        copyStack(otherStack);

	return *this;
}//end operator=

#endif
 //This program tests the various operations of a linked stack

#include <iostream>
#include "linkedStack.h"

using namespace std;

int main()
{
 	//cout<<"See Programming Exercise 1"<<endl;
	linkedStackType<int> myStack;
	linkedStackType<int> yourStack;
	myStack.push(1732);
	myStack.push(1767);
	myStack.push(1734);
	myStack.push(372);
	myStack.push(6929);

	//yourStack = myStack;
     cout << myStack.top() << endl;
        myStack.pop();
     cout << myStack.top() <<endl;
        myStack.pop() ;
     cout << myStack.top() <<endl;
        myStack.pop() ;
     cout << myStack.top() <<endl;
     myStack.pop();
     cout << myStack.top();
	return 0;
}

[jonnin]

that's a lot of code for:

cout <<"6929" << endl; … etc :P

just kidding.

I think you want some form of this pseudocode..

while(mystack.notempty()) //didn't look... you should have an empty checker member somewhere
{
cout<< mystack.top();
mystack.pop();
}

if that program takes 2 seconds to run, something isn't right. Its not important, just saying...

[dhayden]

Put a space after void on line 122. When I do that (and comment out line 215 to run it in one file) it works.

[Bopaki]

Thank you very much jonnin!!!!
I have been battling to write this loop for some time now.

[Bopaki]

Here is what I get:
6929
372
1734
1767
1732

Exactly what I wanted!!!!

[dhayden]

Other comments:

- You don't set or use maxStackSize.
- Your copy constructor doesn't compile. Hint: fix copyStack() and then implement the copy constructor using it:

stackTop = NULL;
copyStack(otherStack);

- The destructor is wrong. It calls delete[] instead of delete and it only deletes the top element in the stack. Just call Destroy() instead.

[Bopaki]

my copyStack function now goes like this:

template class Type>
void linkedStackType<Type>::copyStack
       (const linkedStackType<Type>& otherStack)
{ 
       nodeType<Type> *newNode, *current, *last;
       if( stackTop != NULL)  //if stack is not empty make it empty
              initializeStack();
       if(otherStack.stackTop == NULL)
             stackTop = NULL;
       else
       {
               current = otherStack.stackTop;    //set current to point to the stack to be copied
               //copy the stackTop element of the stack               
              stackTop = new nodeType<Type>;      //create the node
              stackTop->info = current->info;         //copy the info
              stackTop->link = NULL;      //set the link field of the node to NULL
              last = stackTop;           //set last to point to the node
              current = current->link;     //set current to point to the next node
           //copy the remaining stack 
           while( current != NULL)
           {
                   newNode = new nodeType<Type>;
                   newNode->info = current=>info;
                   newNode=>link = NULL;
                   last->link = newNode;
                   last = newNode;
                   current = current->link;
             }    //end while
       }   //end else
}   //end  copyStack
                   last = newNode;

[Bopaki]

It compiles OKAY but bombs out when it runs with message:
Assertion failed: stackTop != NULL, line 136

[jonnin]

re-use your code!
this should read something like
else
while(current)
stacktop.insert(current); //or push or whatever you called it, should reuse that code not rewrite it
current = current->next;

I don't see your bug. But try doing this so you are sure that your insert code is using something you already debugged... if that does not fix it, at least you know the logic is in the remaining bits.