QueueUsingArray.cpp

#include<iostream>
#include<stdio.h>
using namespace std;

#define QUEUE_UNDERFLOW 1;  // defining an exception for empty queue;

class Queue
{
    private:
        int capacity;
        int front;
        int rear;
        int *ptr;
    public:
        Queue();
        Queue(int);
        Queue(Queue&);
        Queue& operator=(Queue &);
        void insertAtRear(int);
        bool isOverflow();
        bool isUnderflow();
        int viewRearElement();
        int viewFrontElement();
        void deleteFront();
        int countElement();
        ~Queue();

};

Queue::Queue()
{
    capacity = 0;
    front = rear = -1;
    ptr = NULL; 
}

Queue::Queue(int cap)   // constructor
{
    capacity = cap;
    front = rear = -1; // initially queue is empty.
    ptr = new int[cap];
}

Queue::Queue(Queue& q)  // copy constructor
{
    capacity = q.capacity;
    front = q.front;
    rear = q.rear;
    ptr = new int[capacity];
    for(int i = 0; i<capacity; i++)
        ptr[i] = q.ptr[i];
}

Queue& Queue::operator=(Queue &q)
{
    if(ptr != NULL)
        delete [] ptr;  // this-> deleting the memory of pointer for( if it containes any other location)
    capacity = q.capacity;
    front = q.front;
    rear = q.rear;
    ptr = new int[capacity];
    for(int i = 0; i<capacity; i++)
        ptr[i] = q.ptr[i];
    return *this;
}

void Queue::insertAtRear(int data)
{
    if(isOverflow())     // when queue is full
        cout<<"Queue Overflow! Data cannot inserted.";

    else if(isUnderflow())  // when queue is empty
    {
        front = rear = 0;
        ptr[front] = data;
    }
    else if(rear == capacity-1)    // when queue is full from rear but front space is empty
    {
        rear = 0;
        ptr[rear] = data;
    }
    else     // normal case
    {
        rear++;
        ptr[rear] = data;
    }
}

bool Queue::isOverflow()    // for checking our queue is full or not
{
    if(rear == capacity-1 && front == 0 || rear + 1 == front)
        return true;        
    else                       
        return false;
}

bool Queue::isUnderflow()   // for checking our queue is empty or not
{
    if(rear == -1 && front == -1)   // checking for both rear or front is not necessary
        return true;
    else
        return false;
}

int Queue::viewRearElement() // for getting last or latest element inserted in queue
{
    if(isUnderflow())
        throw QUEUE_UNDERFLOW; 
    return ptr[rear];
}

int Queue::viewFrontElement() // for getting first or oldest element inserted in queue
{
    if(isUnderflow())
        throw QUEUE_UNDERFLOW;
    return ptr[front];
}

void Queue::deleteFront()
{
    if(isUnderflow())   // when queue is empty
        cout<<"Queue Underflow! Deletion not possible.";
    else if(front == rear)  // when queue has only one element
        front = rear = -1;
    else if(front == capacity-1)   // when front is our last element
        front = 0;
    else    // normal case
        front++; 
}

int Queue::countElement()
{
    if(isOverflow())    // if queue is full 
        return capacity;
    else if(isUnderflow())  // if queue is empty
        return 0;
    else if(rear == front)  // if queue has only one element
        return 1;
    else if(rear > front)   // if rear is greater than front
        return (rear-front+1);
    else 
        return capacity-front+rear+1;   // if any case other than all these
    
}

Queue::~Queue()     
{
    if(ptr != NULL)
        delete [] ptr;  // not necessary to check the NULL Condition because of parametrised constructor.
}