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:
    explicit stack_list(std::vector<T> v = {}) noexcept
    : root(nullptr) {
        if (!v.empty()) {
            for (T &x : v) {
                this->push(x);
            }
        }
    }
 
    explicit stack_list(const stack_list &s) : root(s.root), _size(s._size) {
 
 
    }
 
    stack_list &operator=(const stack_list &s) {
        root = s.root;
        _size = s._size;
        return *this;
    }
 
    void clear() {
        root = nullptr;
        _size = 0;
    }
 
    size_t size() { return _size; }
 
    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++;
        }
    }
 
    T top() { return root->val; }
 
    void pop() {
        root = root->prev;
        root->next = nullptr;
        _size--;
    }
 
    class Iterator;
 
    Iterator begin() { return Iterator(root); }
 
    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