stack.h

Go to the documentation of this file.

 
#ifndef STACK_H
#define STACK_H
 
#include "list.h"
 
#include <initializer_list>
#include <iostream>
#include <utility>
 
namespace dsa
{
 
    template<typename T>
    class Stack;
 
    template<typename T>
    auto operator==(const Stack<T>& stack1, const Stack<T>& stack2) -> bool;
 
    template<typename T>
    auto operator<(const Stack<T>& stack1, const Stack<T>& stack2) -> bool;

    template<typename T>
    class Stack
    {
    public:

        using value_type = T;

        using reference = T&;

        using const_reference = const T&;

        Stack() = default;

        Stack(const std::initializer_list<T>& init_list);

        Stack(const Stack<T>& other);

        auto operator=(const Stack<T>& other) -> Stack&;

        Stack(Stack<T>&& other) noexcept;

        auto operator=(Stack<T>&& other) noexcept -> Stack&;

        ~Stack() = default;

        auto top() -> reference;

        [[nodiscard]] auto top() const -> const_reference;

        [[nodiscard]] auto empty() const -> bool;

        [[nodiscard]] auto size() const -> size_t;

        void push(T value);

        void pop();

        void swap(Stack<T>& other) noexcept;
 
    private:

        friend auto operator==<T>(const Stack<T>& stack1, const Stack<T>& stack2) -> bool;

        friend auto operator< <T>(const Stack<T>& stack1, const Stack<T>& stack2) -> bool;
 
        List<T> container{};
    };
 
    template<typename T>
    Stack<T>::Stack(const std::initializer_list<T>& init_list)
    {
        for (const auto& item : init_list)
        {
            container.push_back(item);
        }
    }
 
    template<typename T>
    Stack<T>::Stack(const Stack<T>& other)
    {
        if (other.size() >= 1)
        {
            for (const auto& item : other.container)
            {
                container.push_back(item);
            }
        }
    }
 
    template<typename T>
    auto Stack<T>::operator=(const Stack<T>& other) -> Stack<T>&
    {
        if (&other != this)
        {
            while (!container.empty())
            {
                container.pop_front();
            }
 
            for (const auto& item : other.container)
            {
                container.push_back(item);
            }
        }
 
        return *this;
    }
 
    template<typename T>
    Stack<T>::Stack(Stack<T>&& other) noexcept
    {
        std::swap(container, other.container);
    }
 
    template<typename T>
    auto Stack<T>::operator=(Stack<T>&& other) noexcept -> Stack<T>&
    {
        if (&other != this)
        {
            std::swap(container, other.container);
        }
 
        return *this;
    }
 
    template<typename T>
    auto Stack<T>::top() -> typename Stack<T>::reference
    {
        return container.back();
    }
 
    template<typename T>
    auto Stack<T>::top() const -> typename Stack<T>::const_reference
    {
        return container.back();
    }
 
    template<typename T>
    auto Stack<T>::empty() const -> bool
    {
        return container.size() == 0;
    }
 
    template<typename T>
    auto Stack<T>::size() const -> size_t
    {
        return container.size();
    }
 
    template<typename T>
    void Stack<T>::push(T value)
    {
        container.push_back(value);
    }
 
    template<typename T>
    void Stack<T>::pop()
    {
        container.pop_back();
    }
 
    template<typename T>
    void Stack<T>::swap(Stack<T>& other) noexcept
    {
        if (&other != this)
        {
            std::swap(container, other.container);
        }
    }

    template<typename T>
    auto operator<<(std::ostream& out, const Stack<T>& stack) -> std::ostream&
    {
        Stack<T> temp{ stack };
 
        while (!temp.empty())
        {
            out << temp.top() << ' ';
            temp.pop();
        }
 
        return out;
    }

    template<typename T>
    auto operator==(const Stack<T>& stack1, const Stack<T>& stack2) -> bool
    {
        return stack1.container == stack2.container;
    }

    template<typename T>
    auto operator!=(const Stack<T>& stack1, const Stack<T>& stack2) -> bool
    {
        return !(operator==(stack1, stack2));
    }

    template<typename T>
    auto operator<(const Stack<T>& stack1, const Stack<T>& stack2) -> bool
    {
        return stack1.container < stack2.container;
    }

    template<typename T>
    auto operator>(const Stack<T>& stack1, const Stack<T>& stack2) -> bool
    {
        return operator<(stack2, stack1);
    }

    template<typename T>
    auto operator<=(const Stack<T>& stack1, const Stack<T>& stack2) -> bool
    {
        return !(operator>(stack1, stack2));
    }

    template<typename T>
    auto operator>=(const Stack<T>& stack1, const Stack<T>& stack2) -> bool
    {
        return !(operator<(stack1, stack2));
    }
 
}
#endif // !STACK_H