stack_list.h

#ifndef STACK_H
#define STACK_H
 
#ifdef __cplusplus
#include <iostream>
#include <memory>
#include <vector>
#endif

template <typename T> class stack_list {
  private:
    struct node {
        T val;
        std::shared_ptr<node> next;
        std::shared_ptr<node> prev;
        node(T key) : val(key), next(nullptr), prev(nullptr) {}
    };
 
    std::shared_ptr<node> root;
    size_t _size{0};
 
  public:
    inline explicit stack_list(std::vector<T> v = {}) noexcept : root(nullptr) {
        if (!v.empty()) {
            for (T& x : v) {
                this->push(x);
            }
        }
    }

    inline explicit stack_list(const stack_list& s) : root(s.root), _size(s._size) {}

    inline stack_list& operator=(const stack_list& s) {
        root = s.root;
        _size = s._size;
        return *this;
    }

    inline void clear() {
        root = nullptr;
        _size = 0;
    }

    inline size_t size() { return _size; }

    inline void push(T key) {
        std::shared_ptr<node> nn = std::make_shared<node>(key);
        if (!root) {
            root = nn;
            _size++;
            return;
        } else {
            root->next = nn;
            nn->prev = root;
            root = nn;
            _size++;
        }
    }

    inline T top() { return root->val; }

    inline void pop() {
        root = root->prev;
        root->next = nullptr;
        _size--;
    }
 
    class Iterator;

    inline Iterator begin() { return Iterator(root); }

    inline Iterator end() { return Iterator(nullptr); }
};

template <typename T> class stack_list<T>::Iterator {
  private:
    std::shared_ptr<node> curr_root;
 
  public:
    explicit Iterator(const std::shared_ptr<node>& s) noexcept : curr_root(s) {}

    Iterator& operator=(std::shared_ptr<node> current) {
        this->curr_root = current;
        return *(this);
    }

    Iterator& operator++() {
        if (curr_root) {
            curr_root = curr_root->prev;
        }
        return *(this);
    }

    Iterator operator++(int) {
        Iterator it = *this;
        ++*(this);
        return it;
    }

    bool operator!=(const Iterator& it) { return curr_root != it.curr_root; }

    T operator*() { return curr_root->val; }
};
 
#endif