Ошибка с функцией peek () класса Stack в c ++

Question

Я пытаюсь реализовать функцию peek () класса Stack, и у меня возникает эта проблема, когда я не могу вернуть верхний объект стека, но вместо этого получаю ошибку. Я попытался удалить функцию & to peek и попытался установить ее в const, но все равно получаю ошибки. Проблема была бы вне этой функции? поскольку я не уверен, что еще я могу попытаться решить эту проблему.

Ошибка:

LStack.h:55:28: error: cannot bind non-const lvalue reference of type ‘int&’ 
to 
an rvalue of type ‘int’
return data.get_current();

LStack.h

#include "LinkedList.h"
#include <cstdlib>
#include <iostream> 

template <typename T>
class LStack
{
    public:
    //mutator member functions
    LStack(){}
    ~LStack(){}

    void push(const T& obj) //insert obj at the top of the stack
    {
        data.add_to_head(obj);
        numofstacks++;
    }

    T pop() //remove and return the top object from the stack, error if stack is empty
    {   
        if (is_empty()){
            std::cout << "Stack is empty";      
        }
        else{
        data.remove_from_head();
        numofstacks--;
        return data.get_current();  
        }
    }

    bool is_empty() const //return a boolean indicating whether the stack is empty
    {
        return (size() == 0);
    }

    //query member functions
    int size() const  //return the number of objects in the stack
    {
        return numofstacks; 
    }
    //return a reference to the object at the top of the stack, NULL if the stack is empty, (also refered to as top())
    T& peek() 
    {
        if (is_empty()){
            std::cout << "Stack is empty";  
        }
        else{
        //return top of the stack object
            return data.get_current();
        }
    }

    private:
    LinkedList<T> data;
    int used;
    int numofstacks;

};

LinkedList.h

#include "Node.h"
#include <cstdlib>
#include <iostream> 

template <typename T>
class LinkedList
{
    public:     
        LinkedList() //constructor
        {
            head = NULL;
            tail = NULL;
            list_length=0;
        }
        ~LinkedList()//destructor since we're creating the linked list on the heap
        {
            while (head != NULL)
            {
              remove_from_head();
            }
            tail = NULL;//not sure if in or out of while loop
        }

        LinkedList(T& item)
        {
            head = new Node<T>();
            head->set_data(item);
            tail = head;
            list_length = 1;
        }

        void add_to_head(T item)
        {
            if (list_length == 0){ //if list is empty
                head = new Node<T>();
                head->set_data(item);
                tail = head;
                list_length = 1;                
            }
            else //Else if list is not empty.. Insert node at the head
            {       
                Node<T>* head_insert = new Node<T>();
                head_insert->set_data(item);                
                head->set_prev(head_insert);
                head_insert->set_next(head);
                head = head_insert;
                list_length++;
                head_insert = NULL;
            }
        }

        void add_to_tail(T item)
        {           
            if (list_length == 0){
                head = new Node<T>();
                head->set_data(item);
                tail = head;
                list_length = 1;
            }
            else  //insert node at tail 
            {               
                Node<T>* tail_insert = new Node<T>();
                tail_insert->set_data(item);
                tail->set_next(tail_insert);
                tail_insert->set_prev(tail);
                tail = tail_insert;
                list_length++;
                tail_insert = NULL;             
            }
        }

        void remove_from_head()
        {
            if (list_length == 0){
                return;
            }
            else if (list_length == 1){

                delete head;
                head = NULL;
                tail = NULL;
                list_length--;
                return;
            }
            else
            {   
                Node<T>* temp_head = head;
                head = temp_head->get_next();
                delete temp_head;
                list_length--;
                temp_head = NULL;
            }
        }

        void remove_from_tail()
        {
            if (list_length == 0){
                return;
            }
            else if (list_length == 1)
            {
                delete head;
                head = NULL;
                tail = NULL;
                list_length--;
                return;
            }
            else
            {
                Node<T>* temp_tail = tail;
                tail = temp_tail->get_prev();
                delete temp_tail;
                list_length--;
                temp_tail = NULL;               
            }
        }   

        std::size_t size()
        {
            return list_length;
        }

        T get_current() // RESULTS IN SEG ERROR
        {
            return current->get_data();
        }           

        void forward()
        {
            current = current->get_next();
        }

        void back()
        {
            current = current->get_prev();
        }

        void move_to_head()
        {
            current = head;
        }

        void move_to_tail()
        {
            current = tail;
        }

        private: //private members
        Node<T>* head; //point to start of list
        Node<T>* tail; //point to end of list
        Node<T>* current; //optional - used to refer to a node in our list
        std::size_t list_length;
};

Может ли проблема быть за пределами этой функции? поскольку я не уверен, что еще я могу попытаться решить эту проблему.