C++ 链表函数故障

尝试为链接列表中的所有函数创建单元测试时遇到问题。主要是我的insert函数有问题，它生成但不插入，我的第一个函数只返回链表第一个槽中的数据

我的代码出现以下错误：newNodeCatch=myList.First

错误C2440“返回”：无法从“int”转换为“ListNode*”UnitTest

另外，我的老师帮助我创建了一个链表，所以我认为这都是正确的代码，但我发现很难理解

source.cpp

LinkedList.h

ListNode.h

---

问题似乎就在这里。报告错误的行号会很有帮助

ListNode<T>* First()
    {
        _ASSERT(start->next != end);
        return start->next->data;
    }

该函数定义为返回指向列表节点的指针，但是您返回的数据在本例中是int，因此编译器准确地报告：错误C2440“return”：无法从“int”转换为“ListNode*”

---

函数应该返回第一个节点，因此应该是：开始->下一步

欢迎使用堆栈溢出。请花点时间阅读并参考您可以在此处询问的内容和方式中的资料。非主题：ListNode.h包括它本身似乎是一个奇怪的选择。为什么需要这样做？首先似乎返回的是数据而不是节点。此外，在将新的newNodeCatch设置为新值之前，不应为其分配空间。在使用链表和其他指针驱动的数据结构时，一个常见的建议是绘制图片。画一张单子。更改列表时，请重新绘制列表。将变化形象化。显示节点之间的连接。如果无法按照代码中的指令s绘制列表，则代码中存在错误，预期图形和生成图形之间的差异将告诉您位置。返回开始->下一步；在这种情况下，是的。但是OP的开始和结束总是指向虚拟节点，这会在以后引起很多额外的麻烦。我已经应用了上面的更改，但现在它告诉我操作数不匹配。我发现我可以删除ListNode*newNode=newlistnode*末尾的*；它构建并返回第一个节点的数据int！在移除额外的*

#pragma once
#include "ListNode.h"
#include <crtdbg.h>

template <typename T>
class Iter
{
    ListNode<T>* current;

public:

    //=
    Iter& operator=(ListNode<T>* other)
    {
        //LinkedList<int> other1;
        current = other;
        return *this;
    }

    //!=
    bool operator!=(ListNode<T>* other)
    {
        if (current != other)
            return true;
        else
            return false;
    }

    //==
    bool operator==(ListNode<T>* other)
    {
        if (current == other)
            return true;
        else
            return false;
    }

    //->
    T value()
    {
        return current->data;
    }

    //++
    void operator++()
    {
        current = current->next;
    }

    //--
    void operator--()
    {
        current = current->prev;
    }
};

template <typename T>
class LinkedList
{
public:

    LinkedList()
    {
        start = new ListNode<T>();
        _ASSERT(start);
        end = new ListNode<T>();
        _ASSERT(end);

        start->next = end;
        end->prev = start;

        start->prev = nullptr;
        end->next = nullptr;
    }

    ~LinkedList()
    {
        delete end;
        delete start;   
    }

    void PushFront(T data)
    {
        ListNode<T>* node = new ListNode<T>();
        _ASSERT(node);
        node->data = data;
        node->next = start->next;
        start->next->prev = node;
        start->next = node;
        node->prev = start;
    }

    void PushBack(T data)
    {
        ListNode<T>* node = new ListNode<T>();
        _ASSERT(node);
        node->data = data;
        node->prev = end->prev;
        end->prev->next = node;
        end->prev = node;
        node->next = end;
    }

    void Insert(ListNode<T>* node)
    {
        ListNode<T>* firstNode = node;
        ListNode<T>* lastNode = node->next;
        ListNode<T>* newNode = new ListNode<T>*;
        //ListNode<T>* newNode = new ListNode<T>;
        _ASSERT(newNode);

        firstNode = newNode->prev;
        lastNode = newNode->next;

        //delete node;
    }

    ListNode<T>* Begin()
    {
        return start->next;
    }

    ListNode<T>* End()
    {
        return end;
    }

    ListNode<T>* First()
    {
        _ASSERT(start->next != end);
        return start->next->data;
    }

    ListNode<T>* Last()
    {
        _ASSERT(end->prev != start);
            return end->prev->data;
    }

    int Count()
    {
        int m_count = 0;

        ListNode<T>* current = start->next;

        while (current != end)
        {
            ++current;
            ++m_count;
        }

        return m_count;
    }

    ListNode<T>* Delete(ListNode<T>* node)
    {
        ListNode<T>* prevNode = node->prev;
        ListNode<T>* nextNode = node->next;

        prevNode->next = nextNode;
        nextNode->prev = prevNode;

        delete node;

        return nextNode;
    }

    void Erase(Iter<T> & target)
    {
        target.current = Delete(target.current);
    }

    void Remove(T value)
    {
        ListNode<T>* current = start->next;

        while (current != end)
        {
            if (current.data == value)
            {
                current = Delete(current);
            }

            else
            {
            ++current;
            }
        }
    }

    void PopBack()
    {
        _ASSERT(end->prev != start);
        Delete(end->prev);
    }

    void PopFront()
    {
        _ASSERT(start->next != end);
        Delete(start->next);
    }

    void Clear()
    {
        ListNode<T>* current = start->next;

        while (current != end)
        {
            current = Delete(current);
            ++current;
        }
    }

private:
    ListNode<T>* start;
    ListNode<T>* end;
    int m_Iterator;
};

#pragma once
#include "ListNode.h"

template <typename T>
class ListNode
{
public:
    ListNode() {};
    ~ListNode() {};

    T data;
    ListNode* next;
    ListNode* prev;
};

ListNode<T>* First()
    {
        _ASSERT(start->next != end);
        return start->next->data;
    }