Stacks

#include <iostream>

using namespace std;

// stack Array
template<class T>
class StackArray{

public:
    StackArray(){
       sz = -1;
       object = new T[CAPACITY];
    }

    T& top(){
        return object[sz];
    }

    T pop(){

       if(size() <= 0)
        return NULL;

       T temp = object[sz];
       sz--;
       return temp;
    }

    void push(T obj){

        object[++sz] = obj;
    }

    int size(){return sz + 1;}

    bool isEmpty(){return (sz < 0);}

    ~StackArray(){

       delete[] object;
    }

private:
    T* object;
    int sz;
    const int CAPACITY = 1000;

};

template<class T>
class Node{

  public:
      T elem;
      Node* next;

      Node(){}
      Node(T elem,Node* next):elem(elem),next(next){}
};

// stack List
template<class T>
class StackList{

public:
    StackList(){
       head = NULL;
       sz = -1;
    }

    T& top(){

       return *head;
    }

    T pop(){

       if(isEmpty())
        return NULL;

       Node<T>* old = head;
       head = old->next;
       sz--;
       T elem = old->elem;
       delete old;
       return elem;
    }

    void push(T obj){

      Node<T>* newNode = new Node<T>(obj,head);
      head = newNode;
      sz++;
    }

    int size(){return sz+1;}

    bool isEmpty(){return (sz < 0);}

    ~StackList(){
       if(!isEmpty()){
        Node<T>* current = head;

        while(current != NULL){

            Node<T>* old = current;
            current = current->next;

            // cout << "delete " << current->elem << endl; will be an error as current will be NULL and print a NULL value
            // cout << "delete " << old->elem << endl; // correct line

            delete old;
        }
       }
       cout << "end" << endl;
    }

private:
    int sz;
    Node<T>* head;

};

// Queue Array
template <class T>
class QueArray{

public:
    QueArray(){

      object = new T[CAPACITY];
      sz = -1;
      f = 0;
      r = 0;
    }

    T& front(){

       return object[f];
    }

    T deque(){

       if(isEmpty())
        return NULL;

       T old = object[f];
       f = (f + 1) % CAPACITY;
       sz--;
       return old;
    }

    void enque(T obj){

       object[r] = obj;
       r = (r + 1) % CAPACITY;
       sz++;
    }

    int size(){return sz + 1;}

    bool isEmpty(){return (sz < 0);}

    ~QueArray(){

       delete[] object;
    }

private:
    T* object;
    int f; // front
    int r; // rear
    int sz;
    const int CAPACITY = 20;
};

int main()
{
    StackArray<char> charStack;
    charStack.push('A');
    charStack.push('D');
    charStack.push('A');
    charStack.push('M');

    for(int i = 0; i < 4; ++i)
        cout << charStack.pop();

    cout << endl << "==============================" << endl;

    QueArray<char> charQue;
    charQue.enque('H');
    charQue.enque('E');
    charQue.enque('L');
    charQue.enque('O');

    cout << charQue.size() << endl;

    for(int i = 0; i < 4; ++i)
        cout << charQue.deque();

    cout << charQue.size() << endl;

    cout << "=================" << endl;

    StackList<char> charList;
    charList.push('H');
    charList.push('E');
    charList.push('L');
    charList.push('O');

    cout << "size " << charList.size() << endl;

    for(int i = 0; i < 4; ++i)
        cout << charList.pop();

    cout << endl;

    cout << "size " << charList.size() << endl;
}