Stack queue in cpp

contents/stacks_and_queues/code/c++/queue.cpp

@@ -0,0 +1,94 @@
+#include<iostream>
+#include<memory>
+#include<cassert>
+
+namespace my {
+    const char endl = '\n';
+    /**
+     * implementation using linked list
+     * [value][next] -> [value][next] -> ... -> [value][next]
+     *  (front Node)   (intermediat Nodes)     (rear Node)
+     */
+    template<typename T>
+    struct Node {
+        /**
+        * next: will store right Node address
+        */
+        T value;
+        std::shared_ptr<Node<T>> next;
+        Node(const T& V) : value(V) { }
+    };
+
+    template<typename T>
+    class queue {
+    private:
+        /**
+         * front_pointer:  points to left most node
+         * count: keeps track of current number of elements present in queue
+         * rear_pointer:  points to most recent Node added into the queue, which is right most Node
+         */
+        std::shared_ptr<Node<T>> front_pointer;
+        std::shared_ptr<Node<T>> rear_pointer;
+        size_t count;
+    public:
+        queue() : count(0ULL) { }
+
+        void push(const T& element) {
+            auto new_node = std::make_shared<Node<T>>(element);
+            if (count > 0) {
+                rear_pointer->next = new_node;
+                rear_pointer = new_node;
+            } else {
+                rear_pointer = front_pointer = new_node;
+            }
+            count = count + 1;
+        }
+
+        void dequeue() {
+            if (count > 1) {
+                front_pointer = front_pointer->next;
+                count = count - 1;
+            } else if (count == 1) {
+                front_pointer.reset();
+                rear_pointer.reset();
+                count = count - 1;
+            }
+        }
+
+        T& front() {
+            assert(count > 0 && "calling front on an empty queue");
+            return front_pointer->value;
+        }
+
+        T const& front() const {
+            assert(count > 0 && "calling front on an empty queue");
+            return front_pointer->value;
+        }
+
+        size_t size() const { return count; }
+
+        bool empty() const { return count == 0; }
+
+        ~queue() {
+            while (front_pointer.get() != nullptr) {
+                front_pointer = front_pointer->next;
+            }
+        }
+    };
+}
+
+int main() {
+    my::queue<int> Q;
+    Q.push(-1);
+    Q.push(1);
+    Q.push(2);
+    Q.push(3);
+    std::cout << "count: " << Q.size() << my::endl;
+    Q.front() = 0;
+
+    while (Q.empty() != true) {
+        std::cout << "element: " << Q.front() << my::endl;
+        Q.dequeue();
+    }
+    return 0;
+}

contents/stacks_and_queues/code/c++/stack.cpp

@@ -0,0 +1,82 @@
+#include<iostream>
+#include<cassert>
+#include<memory>
+
+namespace my {
+    const char endl = '\n';
+    /**
+     * implementation using linked list
+     * [value][next] -> [value][next] -> ... -> [value][next]
+     * (top Node)      (intermediat Nodes)
+     * left most Node represents top element of stack
+     */
+    template<typename T>
+    struct Node {
+        /**
+        * next: will store right Node address
+        */
+        T value;
+        std::unique_ptr<Node<T>> next;
+        Node(const T& V) : value(V) { }
+    };
+
+    template<typename T>
+    class stack {
+    private:
+        /**
+         * top_pointer: points to left most node
+         * count: keeps track of current number of elements present in stack
+         */
+        std::unique_ptr<Node<T>> top_pointer;
+        size_t count;
+    public:
+        stack() : count(0ULL) { }
+
+        void push(const T& element) {
+            auto new_node = std::make_unique<Node<T>>(element);
+            new_node->next = std::move(top_pointer);
+            top_pointer = std::move(new_node);
+            count = count + 1;
+        }
+
+        void pop() {
+            if (count > 0) {
+                top_pointer = std::move(top_pointer->next);
+                count = count - 1;
+            }
+        }
+
+        T& top() {
+            assert(count > 0 and "calling top() on an empty stack");
+            return top_pointer->value;
+        }
+        // returning mutable reference can very be usefull if someone wants to modify top element
+
+        T const& top() const {
+            assert(count > 0 and "calling top() on an empty stack");
+            return top_pointer->value;
+        }
+
+        size_t size() const { return count; }
+
+        bool empty() const { return count == 0; }
+
+        ~stack() {
+            while (top_pointer.get() != nullptr) {
+                top_pointer = std::move(top_pointer->next);
+            }
+        }
+    };
+}
+
+int main() {
+    my::stack<int> S;
+    S.push(3);
+    std::cout << "size: " << S.size() << my::endl;
+    S.top() = 10;
+    while (S.empty() != true) {
+        std::cout << "element: " << S.top() << my::endl;
+        S.pop();
+    }
+    return 0;
+}

contents/stacks_and_queues/stacks_and_queues.md

@@ -20,6 +20,8 @@ Here is a simple implementation of a stack:
 [import, lang:"typescript"](code/typescript/stack.ts)
 {% sample lang="java" %}
 [import, lang:"java"](code/java/Stack.java)
+{% sample lang = "cpp"%}
+[import, lang:"cpp"](code/c++/stack.cpp)
 {% endmethod %}
 
 Here is a simple implementation of a queue:
@@ -28,6 +30,8 @@ Here is a simple implementation of a queue:
 [import, lang:"typescript"](code/typescript/queue.ts)
 {% sample lang="java" %}
 [import, lang:"java" ](code/java/Queue.java)
+{% sample lang = "cpp"%}
+[import, lang:"cpp"](code/c++/queue.cpp)
 {% endmethod %}