Stack Implementation

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

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

class Stack
{
private:
    Node *top;   // Points to topmost element in stack
    size_t size; // Denotes number of elements in queue

public:
    // Default constructor member initialization
    Stack() : top(nullptr), size(0) {}

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

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

    // Insert an element on top of stack
    void push(const int val)
    {
        // Allocate memory for the new element
        Node *newNode = new Node(val);
        // The new node must point to previously topmost item in stack
        newNode->next = top;
        // The updated top of stack is the new node
        top = newNode;
        size++; // Increment size after insertion
    }

    // Get the topmost element in stack (doesn't modify state)
    const int peek()
    {
        if (isEmpty()) {
            throw underflow_error("Cannot access top element in empty stack");
        }
        return top->data;
    }

    // Remove the topmost element from stack
    void pop()
    {
        if (isEmpty()) {
            throw underflow_error("Cannot pop element from empty stack");
        }
        Node *nodeToDelete = top; // Store the topmost node's address
        top = nodeToDelete->next; // Make top point to the second topmost
        delete nodeToDelete;      // Deallocate the top node's memory
        size--;                   // Decrement size after deletion
    }

    // Destructor to deallocate memory of all items of stack
    ~Stack()
    {
        // Keep popping items till stack isn't empty
        while (!isEmpty()) {
            pop();
        }
    }
};

int main()
{
    try {
        // Create an instance of our 'Stack' class
        Stack stk;
        cout << "Size: " << stk.getSize() << endl;
        // Size: 0
        /*
            Access/Delete operations on empty stack will throw underflow exception and exit:

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

            stk.pop();
            // UNDERFLOW: Cannot pop element from empty stack
        */
        stk.push(15); stk.push(48);
        stk.push(23); stk.push(37);
        cout << "Size: " << stk.getSize() << ", Top: " << stk.peek() << endl;
        // Size: 4, Top: 37
        stk.pop();
        stk.pop();
        cout << "Size: " << stk.getSize() << ", Top: " << stk.peek() << endl;
        // Size: 2, Top: 48
    }
    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;
}