ref: rework on stack array data structure

- The `Stack` class is placed within the `data_structures` namespace
- The destructor is added to the Stack class to ensure memory deallocation
- Comments are added to the member functions to describe their purpose
- The self-test function is provided, which demonstrates the usage of the Stack class

Author: sozelfist

data_structures/stack_using_array.cpp

@@ -1,62 +1,133 @@
-#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
 
-void push(int x) {
-    if (stack_idx == stack_size) {
-        std::cout << "\nOverflow";
-    } else {
-        stack[stack_idx++] = x;
+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 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 (stackIndex == stackSize) {
+            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
+     */
+    T pop() {
+        if (stackIndex == 0) {
+            return T();
+        } 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
+     */
+    T topmost() const {
+        if (stackIndex > 0) {
+            return stack[stackIndex - 1];
+        } else {
+            return T();
         }
-    } while (ch != 0);
+    }
+
+    /**
+     * @brief Displays the bottom element of the stack
+     *
+     * @return The bottom element of the stack
+     */
+    T bottom() const {
+        if (stackIndex > 0) {
+            return stack[0];
+        } else {
+            return T();
+        }
+    }
+};
+}  // namespace data_structures
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void test() {
+    data_structures::Stack<int> stack(5);
 
-    delete[] stack;
+    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);
+}
+
+/**
+ * @brief Main function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  // run self-test implementations
     return 0;
 }