LinkedQueue.h - VTC C++ Binary Search Tree Linked Queue

/**
 * [LinkedQueue.h]
 * The LinkedQueue class declaration/specification.
 */

#ifndef LINKEDQUEUE_H
#define LINKEDQUEUE_H

/**
 * Node STRUCTURE:
 * Used to created nodes for the linked queue.
 */
template <class ItemType>
struct Node
{
    ItemType    element;
    Node        *next;
};


template <class ItemType>
class LinkedQueue
{
    /**
     * Everything under public can be accessed by all other programs or classes.
     */
    public:
        /**
         * Constructor(s):
         */
        LinkedQueue();

        /**
         * Destructor:
         */
        ~LinkedQueue();

        /**
         * Mutators:
         */
        void Enqueue(ItemType item);

        /**
         * Accessors:
         */
        void Dequeue(ItemType &item);

        /**
         * General Use:
         */
        void MakeEmpty(void);
        bool IsEmpty(void);
        bool IsFull(void);


    /**
     * Everything under protected can be accessed only by the class itself or (derived) subclasses,
     * as in the case of inheritance.
     */
    protected:


    /**
     * (Private) DATA MEMBERS/PROPERTIES:
     *
     * Everything under private can only be accessed by the class itself (the code in the
     * implementation file).
     */
    private:
        Node<ItemType>  *lq_front;
        Node<ItemType>  *lq_rear;
};

#endif // LINKEDQUEUE_H


/**
 * The LinkedQueue class definition/implementation.
 */

/**
 * LinkedQueue CLASS CONSTRUCTOR(s):
 */
template <class ItemType>
LinkedQueue<ItemType>::LinkedQueue()
{
    lq_front = 0;
    lq_rear = 0;
}


/**
 * LinkedQueue CLASS MUTATORS:
 */
template <class ItemType>
void LinkedQueue<ItemType>::Enqueue(ItemType item)
{
    Node<ItemType>  *newNode = new Node<ItemType>();

    newNode->element = item;
    newNode->next = 0;

        if(lq_rear == 0)
            lq_front = newNode;
        else
            lq_rear->next = newNode;

    lq_rear = newNode;
}


/**
 * LinkedQueue CLASS ACCESSORS:
 */
template <class ItemType>
void LinkedQueue<ItemType>::Dequeue(ItemType &item)
{
    Node<ItemType>  *pTemp;

    pTemp = lq_front;
    item = lq_front->element;
    lq_front = lq_front->next;

        if(lq_front == 0)
            lq_rear = 0;

    delete pTemp;
}


/**
 * LinkedQueue CLASS GENERAL USE FUNCTIONS:
 */
template <class ItemType>
void LinkedQueue<ItemType>::MakeEmpty(void)
{
    Node<ItemType>  *pTemp;

        while(lq_front != 0)
        {
            pTemp = lq_front;
            lq_front = lq_front->next;

            delete pTemp;
        }

    lq_rear = 0;
}

template <class ItemType>
bool LinkedQueue<ItemType>::IsEmpty(void)
{
    return(lq_front == 0);
}

template <class ItemType>
bool LinkedQueue<ItemType>::IsFull(void)
{
    Node<ItemType>  *pTemp = new Node<ItemType>();

        if(pTemp == 0)
            return true;
        else
        {
            delete pTemp;

            return false;
        }
}


/**
 * LinkedQueue CLASS DESTRUCTOR:
 */
template <class ItemType>
LinkedQueue<ItemType>::~LinkedQueue()
{
    MakeEmpty();
}