Rework on Stack Array Data Structure

data_structures/stack_using_array.cpp

@@ -1,62 +1,178 @@
-#include <iostream>
+/**
+ * @file
+ * @brief Implementation of a stack data structure
+ * @details
+ * This implementation provides functionalities to push, pop, and view elements
+ * of the stack. It also includes a self-test method to ensure proper
+ * functionality.
+ */
 
-int *stack;
-int stack_idx = 0, stack_size;
+#include <cassert>    /// For assert
+#include <iostream>   /// For IO operations
+#include <stdexcept>  /// For std::out_of_range
 
-void push(int x) {
-    if (stack_idx == stack_size) {
-        std::cout << "\nOverflow";
-    } else {
-        stack[stack_idx++] = x;
+/*
+ * @namespace
+ * @brief Data structures
+ */
+namespace data_structures {
+/**
+ * @brief Class representation of a stack
+ * @tparam T The type of the elements in the stack
+ */
+template <typename T>
+class Stack {
+ private:
+    T* stack;        ///< Pointer to the stack array
+    int stackSize;   ///< Maximum size of the stack
+    int stackIndex;  ///< Index pointing to the top element of the stack
+
+ public:
+    /**
+     * @brief Constructs a new Stack object
+     *
+     * @param size Maximum size of the stack
+     */
+    Stack(int size) : stackSize(size), stackIndex(0) { stack = new T[size]; }
+
+    /**
+     * @brief Destroys the Stack object
+     */
+    ~Stack() { delete[] stack; }
+
+    /**
+     * @brief Checks if the stack is full
+     *
+     * @return true if the stack is full, false otherwise
+     */
+    bool full() const { return stackIndex == stackSize; }
+
+    /**
+     * @brief Checks if the stack is empty
+     *
+     * @return true if the stack is empty, false otherwise
+     */
+    bool empty() const { return stackIndex == 0; }
+
+    /**
+     * @brief Pushes an element onto the stack
+     *
+     * @param element Element to push onto the stack
+     * @return true if the element was successfully pushed onto the stack, false
+     * otherwise
+     */
+    bool push(T element) {
+        if (full()) {
+            return false;
+        } else {
+            stack[stackIndex++] = element;
+            return true;
+        }
     }
-}
 
-void pop() {
-    if (stack_idx == 0) {
-        std::cout << "\nUnderflow";
-    } else {
-        std::cout << "\n" << stack[--stack_idx] << " deleted";
+    /**
+     * @brief Pops an element from the stack
+     *
+     * @return The popped element
+     * @throws std::out_of_range if the stack is empty
+     */
+    T pop() {
+        if (empty()) {
+            throw std::out_of_range("Stack is empty");
+        } else {
+            return stack[--stackIndex];
+        }
     }
-}
 
-void show() {
-    for (int i = 0; i < stack_idx; i++) {
-        std::cout << stack[i] << "\n";
+    /**
+     * @brief Displays all elements in the stack
+     */
+    void show() {
+        for (int i = 0; i < stackIndex; i++) {
+            std::cout << stack[i] << "\n";
+        }
     }
-}
 
-void topmost() { std::cout << "\nTopmost element: " << stack[stack_idx - 1]; }
-void bottom() { std::cout << "\nBottom element: " << stack[0]; } // If we need access to first element without using pop command 
-int main() {
-    std::cout << "\nEnter stack_size of stack : ";
-    std::cin >> stack_size;
-    stack = new int[stack_size];
-    int ch, x;
-    do {
-        std::cout << "\n0. Exit";
-        std::cout << "\n1. Push";
-        std::cout << "\n2. Pop";
-        std::cout << "\n3. Print";
-        std::cout << "\n4. Print topmost element:";
-        std::cout << "\n5. Print Bottom element:";
-        std::cout << "\nEnter Your Choice : ";
-        std::cin >> ch;
-        if (ch == 1) {
-            std::cout << "\nInsert : ";
-            std::cin >> x;
-            push(x);
-        } else if (ch == 2) {
-            pop();
-        } else if (ch == 3) {
-            show();
-        } else if (ch == 4) {
-            topmost();
-        } else if(ch == 5) {
-            bottom();
+    /**
+     * @brief Displays the topmost element of the stack
+     *
+     * @return The topmost element of the stack
+     * @throws std::out_of_range if the stack is empty
+     */
+    T topmost() const {
+        if (empty()) {
+            throw std::out_of_range("Stack is empty");
+        } else {
+            return stack[stackIndex - 1];
+        }
+    }
+
+    /**
+     * @brief Displays the bottom element of the stack
+     *
+     * @return The bottom element of the stack
+     * @throws std::out_of_range if the stack is empty
+     */
+    T bottom() const {
+        if (empty()) {
+            throw std::out_of_range("Stack is empty");
+        } else {
+            return stack[0];
         }
-    } while (ch != 0);
+    }
+};
+}  // namespace data_structures
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void test() {
+    data_structures::Stack<int> stack(5);
+
+    // Test push, pop, topmost, bottom, full, and empty operations
+    assert(stack.empty() == true);
+    assert(stack.full() == false);
+
+    assert(stack.push(10) == true);
+    assert(stack.push(20) == true);
+    assert(stack.push(30) == true);
+    assert(stack.push(40) == true);
+    assert(stack.push(50) == true);
+    assert(stack.push(60) == false);
+
+    assert(stack.pop() == 50);
+    assert(stack.pop() == 40);
+    assert(stack.pop() == 30);
+
+    assert(stack.topmost() == 20);
+    assert(stack.bottom() == 10);
 
-    delete[] stack;
+    assert(stack.pop() == 20);
+    assert(stack.pop() == 10);
 
+    assert(stack.empty() == true);
+    assert(stack.full() == false);
+
+    // Test for exceptions when stack is empty
+    try {
+        stack.topmost();
+    } catch (const std::out_of_range& e) {
+        assert(std::string(e.what()) == "Stack is empty");
+    }
+
+    try {
+        stack.bottom();
+    } catch (const std::out_of_range& e) {
+        assert(std::string(e.what()) == "Stack is empty");
+    }
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  // run self-test implementations
     return 0;
 }