Node* 类型值如何以迭代器类型返回？

如何解决Node* 类型值如何以迭代器类型返回？

我创建了一个链表类，它有一个 Node 类型的头指针。 在方法 begin() 中，我想返回一个 Iterator 类型的对象。 但是如果我在 begin() 方法中返回一个 Node* 类型的指针，它就能够正常编译和运行。为什么？？？

class LinkedList {
    class Node;
    Node* head;

public:
    class Node {
    public:
        int data;
        Node* next;
        Node(int item) : data{ item },next{ } { }
    };

    void insert(std::initializer_list<int> list) {
        head = nullptr;
        Node* ptr{};
        for (auto ele : list) {
            if (head == nullptr) {
                head = new Node(ele);
                ptr = head;
                continue;
            }
            
            ptr->next = new Node(ele);
            ptr = ptr->next;
        }
    }

    void printList() {
        Node* ptr = head;
        
        while (ptr) {
            std::cout << ptr->data << " ";
            ptr = ptr->next;
        }
    }

class Iterator {
        Node* m_ptr;
    public:
        std::forward_iterator_tag o1;
        std::ptrdiff_t p1{};
        using value_t = Node;
        using pointer_t = Node*;
        using reference_t = Node&;

        Iterator(pointer_t ptr) : m_ptr{ ptr } {}
        
        reference_t operator*() { return *m_ptr; }
        pointer_t operator->() { return m_ptr; }
        Iterator& operator++() {
            m_ptr++;
            return *this;
        }
        Iterator operator++(int) {
            pointer_t temp = m_ptr;
            ++m_ptr;
            return temp;
        }
        friend bool operator==(const Iterator& a,const Iterator& b) { return a.m_ptr == b.m_ptr; }
        friend bool operator!=(const Iterator& a,const Iterator& b) { return a.m_ptr != b.m_ptr; }

    };

    Iterator begin() { return head; }
    Iterator end() {
        Node* ptr = head;
        
        while (ptr->next != nullptr) {
            ptr = ptr->next;
        }

        return ptr;
    }
};

解决方法

它通过 Iterator(pointer_t ptr) 构造函数将 Node* 隐式转换为 Iterator。