Ytdyklly

I'm working on a stack implementation using a linked list, but I have a strong feeling that I overcomplicated my solution. I would appreciate it if you review this code and give me any suggestions on code and style.

#pragma once

#include <functional>

#include <iostream>

#include <type_traits>

#include <stdexcept>

template <typename T>

class StackList

{

private:

    class Node

    {

        T data;

        Node * next;

        Node(Node * next, const T & data) :next(next), data(data) {};

        friend class StackList<T>;

    };

    int size_ = 0;

    Node * head_ = nullptr;

    Node * tail_ = nullptr;

    void AddToTail(T& data);

public:

    StackList() = default;

    StackList(StackList & other);

    StackList(StackList && other);

    StackList & operator=(StackList & other);

    StackList & operator=(StackList && other);

    ~StackList() { EmptyList(); }



    void EmptyList();

    void push(const T & data);

    T pop();

    const T& operator(int count) const; 

    T& operator(int count) { return const_cast<T &>(static_cast<const StackList &>(*this).operator(count)); };

    int size() { return size_; }

    void Traverse(std::function<void(T&)> lamda) const;

    void Traverse(std::function<void(T&)> lamda){ (static_cast<const StackList &>(*this).Traverse(lamda)); }



    template <typename T>

    friend std::ostream & operator<<(std::ostream & os, StackList<T> & stack);

};



template <typename T>

void StackList<T>::AddToTail(T& data)

{

    if (head_ == nullptr)

        head_ = tail_ = new Node(nullptr, data);

    else

    {

        tail_->next = new Node(nullptr, data);

        tail_ = tail_->next;

    }

}



template <typename T>

StackList<T>::StackList(StackList & other)

{

    std::function<void(T&)> lamda = [&](T& data) {this->AddToTail(data); this->size_++; };

    other.Traverse(lamda);

}



template <typename T>

StackList<T>::StackList(StackList && other) : head_(other.head_), tail_(other.tail_), size_(other.size_)

{

    other.head_ = 0;

    other.tail_ = 0;

    other.size_ = 0;

}



template <typename T>

StackList<T> & StackList<T>::operator=(StackList<T> & other)

{

    if (this != &other)

    {

        if (other.size_ == 0)

            EmptyList();

        else

        {

            if (size_ >= other.size_)

            {

                Node * current = head_;

                std::function<void(T&)> lamda = [&](T& data) {current->data = data; tail_ = current; current = current->next; };

                other.Traverse(lamda);

                while (current != nullptr)

                {

                    Node * save = current->next;

                    delete current;

                    current = save;

                }

            }

            else

            {

                Node * current = other.head_;

                std::function<void(T&)> lamda = [&](T& data) {data = current->data; current = current->next; };

                Traverse(lamda);

                while (current != nullptr)

                {

                    AddToTail(current->data);

                    current = current->next;

                }

            }

            tail_->next = nullptr;

            size_ = other.size_;

        }

    }

    return *this;

}



template <typename T>

StackList<T> & StackList<T>::operator=(StackList<T> && other)

{

    if (this != &other)

    {

        head_ = other.head_;

        tail_ = other.tail_;

        size_ = other.size_;

        other.head_ = 0;

        other.tail_ = 0;

        other.size_ = 0;

    }

    return *this;

}



template <typename T>

const T& StackList<T>::operator(int count) const

{

    if (count > size_ - 1 && count < 0)

        throw std::invalid_argument("Out of range index!");

    Node * search = head_;

    for (int i = 0; i < count; i++)

        search = search->next;

    return search->data;

}



template <typename T>

void StackList<T>::EmptyList()

{

    while (head_ != nullptr)

        pop();

}



template <typename T>

void StackList<T>::push(const T & data)

{

    head_ = new Node(head_, data);

    if (tail_ == nullptr)

        tail_ = head_;

    size_++;

}



template <typename T>

T StackList<T>::pop()

{

    if (size_ > 0)

    {

        T retval = head_->data;

        Node * temp = head_->next;

        delete head_;

        head_ = temp;

        size_--;

        if (size_ == 0)

            head_ = tail_ = nullptr;

        return retval;

    }

    else

    {

        throw std::invalid_argument("Pop of empty list");

    }



}

template <typename T>

void StackList<T>::Traverse(std::function<void(T&)> lamda) const

{

    Node * cur = head_;

    while (cur != nullptr)

    {

        lamda(cur->data);

        cur = cur->next;

    }

}



template <typename T>

std::ostream & operator<<(std::ostream & os, StackList<T> & stack)

{

    std::function<void(T&)> lamda = [&](T& data) { os << data << std::endl; };

    std::ios_base::fmtflags f(os.flags());

    os << "Stack of " << typeid(T).name() << ", size = " << stack.size() << std::endl;

    stack.Traverse(lamda);

    os.flags(f);

    return os;

}