Как работает перегрузка оператора ++ для перебора моего LinkedList

Это мое пространство имен LinkedList

namespace LinkedList {     
    template<class T>
    class Node{
    public:
        Node(const T& data)
            :data_(data), next_(nullptr) {}
        T data_;
        Node<T> *next_;

        Node<T> *operator++(){
            return next_;
        }
    };


    

    template<class T>
    class LinkedList{
    public:
        LinkedList()
            : head_(nullptr), tail_(nullptr) {}
        
        ~LinkedList(){
            Node<T> *curr = head_;
            Node<T> *next;
            while(curr != nullptr){
                next = curr->next_;
                delete curr;
                curr = next;
            }
        }
        void Append(const T& data) {
            Node<T> *tmp = new Node<T>(data);
            if (head_ == nullptr) {
                head_ = tmp;
                tail_ = tmp;
            } else if (head_ == tail_){
                head_->next_ = tmp;
                tail_ = tmp;
            } else {
                tail_->next_ = tmp;
                tail_ = tmp;
            }
        }

        void Present(){
            for(Node<T> *curr = head_; curr != nullptr; curr=curr->next_){
                std::cout << curr->data_ << std::endl;
            }
        }

        Node<T> *begin(){
            return head_;
        }

        Node<T> *end(){
            return nullptr;
        }
    private:
        Node<T> *head_;
        Node<T> *tail_;
    };
}

Я читал Iterators и хотел, чтобы мой объект LinkedList был совместим с диапазоном на основе циклов for. Это то, что я получил, прочитав о циклах for на основе диапазона

for(auto x: list){ }

эквивалентно

for(; begin != end; ++begin) { //*begin};

Я думал, что был дерзким и мог пропустить пару шагов перегрузки оператора (!=, *), чтобы мой LinkedList работал с диапазоном, основанным на циклах for, запрограммировав мой итератор в мой класс Node ни по какой другой причине, кроме того, что мне так хотелось. Я только второй день изучаю С++, поэтому это может быть глупый вопрос, но я все еще немного смущен тем, почему это не работает:

LinkedList::LinkedList<int> list;
list.Append(3);
list.Append(5);
for(auto x: list) { //blah blah blah}

Я знаю, что приращение моего префикса является основной проблемой, когда цикл for выполняет ++__begin, я надеюсь, что он делает ___begin=_begin->next, но это не так. Почему это? На мой взгляд, перегрузка оператора работает следующим образом: любые переменные-члены, на которые я ссылаюсь в функции перегрузки, ссылаются на экземпляр, над которым я работаю. И когда я возвращаю ptr, он устанавливает любой экземпляр, над которым я работаю, на этот ptr. Я знаю, что мое понимание этого неверно, потому что это не работает, поэтому, пожалуйста, кто-нибудь объясните мне, как это на самом деле работает, лол.