Queue Implementation

// Definition of a Node for the linked-list used by the Queue internally
class Node
{
private:
    int data;
    Node *next;
    // To allow 'Queue' class to access private members of 'Node' class
    friend class Queue;

public:
    // Parameterized constructor member initialization
    Node(const int val) : data(val), next(nullptr) {}
};

class Queue
{
private:
    Node *front; // Points to first (front-most) element in queue
    Node *rear;  // Points to last (rear-most) element in queue
    size_t size; // Denotes number of elements in queue

public:
    // Default constructor member initialization
    Queue() : front(nullptr), rear(nullptr), size(0) {}

    // Check if queue is empty (doesn't modify state)
    const bool isEmpty()
    {
        // Queue is empty when front is not pointing to anything
        return (front == nullptr);
    }

    // Returns number of elements present in queue (doesn't modify state)
    const size_t getSize() { return size; }

    // Returns first element, present at front of queue (doesn't modify state)
    const int first()
    {
        if (isEmpty()) {
            throw underflow_error("Cannot access front element in empty queue");
        }
        return front->data;
    }

    // Returns last element, present at rear of queue (doesn't modify state)
    const int last()
    {
        if (isEmpty()) {
            throw underflow_error("Cannot access rear element in empty queue");
        }
        return rear->data;
    }

    // Insert an element at end of queue
    void enque(const int val)
    {
        // Allocate memory for the new element
        Node *newNode = new Node(val);

        if (isEmpty()) { // The queue was empty before
            // Both front and rear will point to the only existing inserted element
            front = rear = newNode;
        } else { // The queue had one or more existing elements before
            // Attach new node after the old rear
            rear->next = newNode;
            // Updated rear of queue is the new node
            rear = newNode;
        }
        size++; // Increment size after insertion
    }

    // Remove an element from front of queue
    void deque()
    {
        if (isEmpty()) {
            throw underflow_error("Cannot remove element from empty queue");
        }
        // Store the first node's address
        Node *nodeToDelete = front;
        // Make front point to the node after first (can be null)
        front = front->next;
        if (!front) { // When there was only one existing element (it's next is null)
            // Both front and rear would become null after deletion in this case
            rear = front;
        }
        delete nodeToDelete; // Deallocate the first node's memory
        size--; // Decrement size after deletion
    }

    // Destructor to deallocate memory of all items of queue
    ~Queue()
    {
        // Keep deque-ing items till queue isn't empty
        while (!isEmpty()) {
            deque();
        }
    }
};

int main()
{
    try {
        // Create an instance of our 'Queue' class to store jobs scheduled
        Queue jobs;
        cout << "size=" << jobs.getSize() << endl;
        // size=0
        /*
            Access/Delete operations on empty queue will throw underflow exception and exit:

            cout << jobs.first() << endl;
            // UNDERFLOW: Cannot access top element in empty stack

            cout << jobs.last() << endl;
            // UNDERFLOW: Cannot access rear element in empty queue

            jobs.deque();
            // UNDERFLOW: Cannot remove element from empty queue

        */
        jobs.enque(12);
        cout << "size=" << jobs.getSize() << ", first=" << jobs.first() << ", last=" << jobs.last() << endl;
        // size=1, first=12, last=12

        jobs.enque(45); jobs.enque(28);
        jobs.enque(39); jobs.enque(88);
        cout << "size=" << jobs.getSize() << ", first=" << jobs.first() << ", last=" << jobs.last() << endl;
        // size=5, first=12, last=88

        jobs.deque(); jobs.deque();
        cout << "size=" << jobs.getSize() << ", first=" << jobs.first() << ", last=" << jobs.last() << endl;
        // size=3, first=28, last=88
    }
    catch (underflow_error const &ue) {
        cout << "UNDERFLOW: " << ue.what() << endl;
    }
    catch (overflow_error const &oe) {
        cout << "OVERFLOW: " << oe.what() << endl;
    }
    catch (exception const &e) {
        cout << "Other exception: " << e.what() << endl;
    }

    return 0;
}