C++ C++；C2440'&书信电报；功能样式转换>'；：无法从'；节点<；T>*常数'；至'；迭代器<；常数T>'；

我一直在尝试为我的链表实现创建迭代器。但是我犯了一个错误。我的实施情况如下：

#ifndef LinkedListIterative_h
#define LinkedListIterative_h

#include <cstdio>

using std::swap;

template <typename T>
class LinkedList;

template <typename T>
class Iterator;

template<typename T>
class Node
{
    private:
        friend class Iterator<T>;
        friend class LinkedList<T>;        

        T data;
        Node *next;

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

template<typename T>
class Iterator
{
    private:
        Node<T> *node;

    public:
        Iterator() : node(nullptr) {}

        Iterator(Node<T> *node) : node(node)  {}

        Iterator(const Node<T> *node) : node(node)  {}

        Iterator(const Iterator& iterator) : node(iterator.node)
        {

        }

        Iterator& operator= (const Iterator& rhs)
        {
            if( this != &rhs )
            {
                node = rhs.node;
            }
        }

        Iterator& operator++()
        {
            node = node->next;

            return *this;
        }

        Iterator& operator+(size_t index)
        {
            while( index-- > 0 && (node != nullptr) )
            {
                ++this;
            }

            return *this;
        }

        Iterator& operator[](size_t index)
        {
            while( index-- > 0 && (node != nullptr) )
            {
                ++this;
            }

            return *this;
        }

        bool operator==(const Iterator &iter)
        {
            return node == iter.node;
        }

        bool operator!=(const Iterator &iter)
        {
            return node != iter.node;
        }

        T& operator*() { return node->data; }

};

template <typename T>
class LinkedList
{
    private:
        size_t size;
        Node<T> *first;
        Node<T> *last;

        Node<T>* createNode(const T &item)
        {
            Node<T> *node = new Node<T>;

            node->data = item;
            node->next = nullptr;

            return node;
        }

        LinkedList(const LinkedList& list){}

        LinkedList& operator=(const LinkedList& list){}

    public:
        typedef Iterator<T> iterator;
        typedef Iterator<const T> const_iterator;

        LinkedList() : size(0), first(nullptr), last(nullptr)
        {

        }

        // Add item at the end of the list
        void add(const T& item)
        {
            Node<T> *node = createNode(item);

            if(first == nullptr)
            {
                first = node;
                last  = node;
            }
            else
            {
                last->next = node;
                last = node;
            }

            ++size;
        }

        void add(const T& item,size_t index)
        {
            if( size == 0 )
            {
                add(item);
            }
            else if( index == 0 && size > 0 )
            {
                addToFirst(item);
            }
            else if( index >= size )
            {
                addToLast(item);
            }
            else
            {
                Node<T> *prev = first;
                Node<T> *curr = first;

                int i = 0;

                while( i++ < index  )
                {
                    prev = curr;
                    curr = curr->next;
                }

                Node<T> *node = createNode(item);

                prev->next = node;
                node->next = curr;

                ++size;
            }
        }

        void addToFirst(const T& item)
        {
            Node<T> *node = createNode(item);

            node->next = first;

            first = node;

            if(size == 0)
                last = node;

            ++size;
        }

        void addToLast(const T& item)
        {
            Node<T> *node = createNode(item);

            last->next = node;

            last = node;

            if(size == 0)
                first = node;

            ++size;
        }

        void removeFirst()
        {
            if( first == nullptr )
                return;

            Node<T> *temp = first;

            first = first->next;

            --size;

            delete temp;

            if( size == 0 )
                last = first;
        }

        void remove(const size_t index)
        {
            if( size == 0 || index > size - 1 )
                throw std::out_of_range("Out of range");

            if(index == 0)
            {
                removeFirst();
                return;
            }

            Node<T> *curr = first;
            Node<T> *prev = first;

            size_t i(0);

            while( i++ < index )
            {
                prev = curr;
                curr = curr->next;
            }

            if( curr == last )
            {
                last = prev;
            }

            prev->next = curr->next;

            delete curr;

            --size;
        }

        void removeLast()
        {
            if( first == nullptr )
                return;

            Node<T> *curr = first;
            Node<T> *prev = first;

            while( curr != last )
            {
                prev = curr;
                curr = curr->next;
            }

            prev->next = nullptr;

            delete last;

            last = prev;

            --size;

            if( size == 0 )
                first = last;
        }

        T& getItem(size_t index) const
        {
            if(index > size)
                throw std::out_of_range("index out of bound!");

            Node<T> *curr = first;

            size_t i = 0;

            while ( i++ != index )
                curr = curr->next;

            return curr->data;
        }

        size_t length() const
        {
            return size;
        }

        iterator begin()
        {
            return iterator(first);
        }

        iterator end()
        {
            return iterator(last); //getting error here
        }

        const_iterator begin() const
        {
            return const_iterator(first);
        }

        const_iterator end() const
        {
            const_iterator(last);
        }

        ~LinkedList()
        {
            Node<T> *curr = first;

            while( curr != last )
            {
                Node<T> *temp = curr;

                curr = curr->next;

                delete temp;
            }
        }           
};


#endif /* LinkedListIterative_h */

#如果ndef linkedlist\h
#定义LinkedListIterative\u h
#包括
使用std：：swap；
模板
类链接列表；
模板
类迭代器；
模板
类节点
{
私人：
友元类迭代器；
朋友类链接列表；
T数据；
节点*下一步；
Node（）：next（nullptr）{}
节点（const T&data）：数据（data）{}
};
模板
类迭代器
{
私人：
节点*节点；
公众：
迭代器（）：节点（nullptr）{}
迭代器（Node*Node）：节点（Node）{}
迭代器（const Node*Node）：节点（Node）{}
迭代器（常量迭代器&迭代器）：节点（迭代器.节点）
{
}
迭代器和运算符=（常量迭代器和rhs）
{
如果（此！=&rhs）
{
node=rhs.node；
}
}
迭代器和运算符++（）
{
节点=节点->下一步；
归还*这个；
}
迭代器和运算符+（大小索引）
{
而（索引-->0&（节点！=nullptr））
{
++这,；
}
归还*这个；
}
迭代器和运算符[]（大小索引）
{
而（索引-->0&（节点！=nullptr））
{
++这,；
}
归还*这个；
}
布尔运算符==（常量迭代器和iter）
{
返回节点==iter.node；
}
布尔运算符！=（常量迭代器和iter）
{
返回节点！=iter.node；
}
运算符*（）{return node->data；}
};
模板
类链接列表
{
私人：
大小；
节点*第一；
节点*最后；
节点*createNode（常量T和项目）
{
节点*节点=新节点；
节点->数据=项目；
节点->下一步=nullptr；
返回节点；
}
LinkedList（常量LinkedList&list）{}
LinkedList和运算符=（常量LinkedList和列表）{}
公众：
typedef迭代器；
typedef迭代器const_迭代器；
LinkedList（）：大小（0）、第一个（nullptr）、最后一个（nullptr）
{
}
//在列表末尾添加项目
无效添加（常数T和项目）
{
节点*节点=创建节点（项）；
if（first==nullptr）
{
第一个=节点；
last=节点；
}
其他的
{
last->next=节点；
last=节点；
}
++大小；
}
无效添加（常量和项目、大小和索引）
{
如果（大小==0）
{
增加（项目）；
}
else if（索引==0&&size>0）
{
添加到第一个（项目）；
}
否则如果（索引>=大小）
{
addToLast（项目）；
}
其他的
{
节点*prev=第一个；
节点*curr=第一个；
int i=0；
while（i++下一步；
}
节点*节点=创建节点（项）；
上一步->下一步=节点；
节点->下一步=当前；
++大小；
}
}
无效添加到第一项（常数和项目）
{
节点*节点=创建节点（项）；
节点->下一步=第一步；
第一个=节点；
如果（大小==0）
last=节点；
++大小；
}
void addToLast（常数和项目）
{
节点*节点=创建节点（项）；
last->next=节点；
last=节点；
如果（大小==0）
第一个=节点；
++大小；
}
void removeFirst（）
{
if（first==nullptr）
返回；
节点*温度=第一；
第一个=第一个->下一个；
--大小；
删除临时文件；
如果（大小==0）
最后=第一；
}
无效删除（常量大小\u t索引）
{
如果（大小==0 | |索引>大小-1）
抛出标准：：超出范围（“超出范围”）；
如果（索引==0）
{
移除第一个（）；
返回；
}
节点*curr=第一个；
节点*prev=第一个；
尺寸i（0）；
while（i++下一步；
}
如果（当前==上次）
{
最后=上一个；
}
上一个->下一个=当前->下一个；
删除curr；
--大小；
}
void removeLast（）
{
if（first==nullptr）
返回；
节点*curr=第一个；
节点*prev=第一个；
while（curr！=上次）
{
上一次=当前；
当前=当前->下一步；
}
prev->next=nullptr；
最后删除；
最后=上一个；
--大小；
如果（大小==0）
第一个=最后一个；
}
获取项目（大小索引）常量（&T）
{
如果（索引>大小）
抛出std：：超出范围（“索引超出范围！”）；
节点*curr=第一个；
尺寸i=0；
而（i++！=索引）
当前=当前->下一步；
返回当前->数据；
}
大小\u t长度（）常数
{
返回大小；
}
迭代器begin（）
{
返回迭代器（第一）；
}
迭代器结束（）
{
返回迭代器（最后）；//获取
Error C2440 '<function-style-cast>': cannot convert from 'Node<T> *const ' to 'Iterator<const T>'   

void printList(const LinkedList<int>& list)
{
    size_t index = 0;

    LinkedList<int>::const_iterator iter = list.begin();

    for(; iter != list.end(); ++iter)
    {
        std::cout << *iter << " ";
    }

    while( index < list.length() )
    {
        std::cout << list.getItem(index ++) << " ";
    }

    std::cout << std::endl;
}