g++ [flags ...] file ...

#include <Stack.h>
Stack();
boolean assign(const Stack<TObject>& copy_stack);
boolean push(TObject* item);
TObject* pop(TObject* item = (TObject*)NULL);
const TObject* peek() const;
boolean pop(Stack<TObject>& item_stack, long num_items);
boolean clear();

// declare a character stack and push two characters into it
//
Stack<Char> stack;
Char item0(L'a');
Char item1(L'b');
stack.push(&item0);
stack.push(&item1);

// pop the top item from the stack
//
Char* item2 = new Char();
stack.pop(item2);

if(!item2->eq(item1)) {
  // error
}

T. Cormen, C. Leiserson, R. Rivest, Introduction to Algorithms, MIT Press, Boston, Massachusetts, USA, pp. 200-203, 1998.

• none.

• This example shows the basic operation of a stack.

  #include <Char.h>
  #include <Stack.h>
  
  int main () {
  
    // local variables
    //
    Stack<Long> s;
    Long j;
  
    // add 10 items to the stack
    //       
    for (long i = 0; i < 10; i++) {
      j = i * 3;
      s.push(&j);
    }
  
    // see what is on the stack
    //       
    s.debug(L"after push");
  
    // pull things off the stack and print them in order
    //       
    while (s.pop(&j) != (Long*)NULL) {
      j.debug(L"pulled off stack");
    }
         
    // exit gracefully
    //
    Integral::exit();
  }       
         

• This example shows the basic operation of a stack in reference mode. Note that memory is manually allocated before pushing it to the stack and deleted upon popping.

  #include <Char.h>
  #include <Stack.h>
  
  int main () {
  
    // local variables (note that the stack is set to reference mode)
    //
    Stack<Long> s(USER);
    Long* j;
  
    // add 10 items to the stack
    //       
    for (long i = 0; i < 10; i++) {
      j = new Long(i * 3);
      s.push(j);
    }
  
    // see what is on the stack
    //       
    s.debug(L"after add");
  
    // pull things off the stack and print them in order
    //       
    while ((j = s.pop()) != (Long*)NULL) {
      j->debug(L"pulled off stack");
      delete j;
    }
         
    // exit gracefully
    //
    Integral::exit();
  }       
         

• This example shows how to check if Stacks are equal:

  #include <Char.h>
  #include <Stack.h>
  
  int main () {
  
    // prepare items for the stack
    //
    Char** items = new Char*[5];
    for (long i = 0; i < 5; i++) {
       items[i] = new Char((unichar)((long)(L'a') + i));
    }
  
    // declare a stack and push items into it
    //
    Stack<Char> char_stack;
    char_stack.push(items, 5);
  
    // copy the stack
    //
    Stack<Char> copy_char_stack(char_stack);
  
    // see if these Stacks are equivalent
    //
    if(!char_stack.eq(copy_char_stack)) {
         
      // exit with error
      //
      Integral::exit();
      
    }
         
    // clean up the memory used
    //
    for (long i = 0; i < 5; i++) {
      delete items[i]; 
    }
    delete [] items; 
    
    // exit gracefully
    //
    Integral::exit();
  }
  

• There are two allocation modes for Stack. Only the internal DoubleLinkedList is always in USER mode. this linked list will never be SYSTEM-allocating as the user would not be able to use the pop'd elements if the list was SYSTEM-allocating.
  
  
• Unlike other classes, we have two read and write methods in dstr classes. The interface is still the same as that in other classes. The reason behind this is that we can not use "CLASS_NAME" as default argument in the read and write methods here because the data structures build the class name on the fly.