Thread: accessing classes and reversing inputs

yes, i know the latter topic is common. but theres a twist: a predefined class.

i have a predefined class for a stack that brings up a menu where you can push, pop, and peek. now i have to use this class in order to display what the user has pushed onto the stack, in reverse.

now this class uses new concepts like the 'new' operator in conjustion with pointers to allow any number of...numbers, to be input. ive read, and read, and read, but pointers are still weird to me in usage (although i do understand the concepts).

i was thinking of using the pop function to display the stack in reverse(loop it till it hits the null charcter), but in order to do that, i would have to allow for another user option. is this possible to do in my custom function that im writing or do i need to modify the existing class?

im also not sure how to access the actual inputs for things like sequencing and ordering, since theyre coupled with the 'new' operator...

i can provide code but was hoping to avoid the easy way out (someone doing the actual coded solution)

thanks!

A Stack element would be something like

Code:

template<class T> struct StackNode{
   struct StackNode* next;
   T element;
}

and to print it in both normal and reverse order

Code:

//normal
template<class T> void print_node(struct StackNode<T> *node){
    if(node==NULL)
        return;
    //print element. maybe std::cout<<node->element;
    print_node(node->next);
}
//reverse
template<class T> void print_node(struct StackNode<T> *node){
    if(node==NULL)
        return;
    print_node(node->next);
    //print element. maybe std::cout<<node->element;
}

It very simple as you can see...

When I think of stacks I think of access being restricted to the last item entered. That access is by popping the last element off, thereby altering the stack. That type of access differs from arrays or lists where you can access any member you want without altering the contents of the container using using the []operaotor or pointers or iterators, whatever. Therefore I wouldn't use pointers/iterators to access the elements of the stack as xErath did. I'd pop elements off the stack one by one and display them as they are popped off to display the contents of the stack in reverse order of entry. To display the contents in order of entry I'd pop elements off the first stack one by one and push them onto a second stack as they are popped from the first. Then I'd pop and display elements of the second stack one by one.

so...have a function that automatically pops off every node, then as it does, display it? i know youd have to set up a loop:

Code:

while node does not equal NULL
     pop node
     print node
     if the current node equals NULL
        return

right?

i see what yer sayin xErath, just flip the order of the print lines (current then next current for the reverse). but, at this point, the way youve done it is a bit over my head in terms of pointers/iterators (although im sure its easier if you understand what youre doing! )

That way you'll have to do this.

Code:

Stack thestack//the original
Stack backup//empty
while thestack.size() !=0
    element = thestack.pop()
    print element
    backup.push(element)
//then restore the original stack back
while backup.size() !=0
    element = backup.pop()
    thestack.push(element)

If you don't do this, you'll loose you orbjects, if you don't store them, and you'll have a reversed stack if you don't rebuilt the original one from the backup.
Again, I strongly advise my method, but by method would have to be friend of the class or a class method... method, method

ah, so i cant just do this in a different function, i have to modify the original class in order to access the private data