How to Implement Iterator for a Doubly Linked List in C++?

// C++ program to implement iterator for doubly linked list

#include <iostream>
using namespace std;

// Node structure for doubly linked list
struct Node {
    int data;
    Node* prev;
    Node* next;

    // Constructor to initialize node with a value
    Node(int value)
        : data(value)
        , prev(nullptr)
        , next(nullptr)
    {
    }
};

// Iterator class for doubly linked list
class DoublyLinkedListIterator {
private:
    Node* current; // Current node pointer

public:
    // Constructor to initialize iterator with a node
    DoublyLinkedListIterator(Node* node)
        : current(node)
    {
    }

    // Dereference operator to return reference to data
    int& operator*() { return current->data; }

    // Prefix increment operator to move to next node
    DoublyLinkedListIterator& operator++()
    {
        current = current->next;
        return *this;
    }

    // Prefix decrement operator to move to previous node
    DoublyLinkedListIterator& operator--()
    {
        current = current->prev;
        return *this;
    }

    // Inequality operator to compare iterators
    bool
    operator!=(const DoublyLinkedListIterator& other) const
    {
        return current != other.current;
    }

    // Equality operator to compare iterators
    bool
    operator==(const DoublyLinkedListIterator& other) const
    {
        return current == other.current;
    }
};

// Doubly linked list class
class DoublyLinkedList {
private:
    // Pointer to head of the list
    Node* head;
    // Pointer to tail of the list
    Node* tail;

public:
    // Constructor to initialize an empty list
    DoublyLinkedList()
        : head(nullptr)
        , tail(nullptr)
    {
    }

    // Function to append a new node with given value to the
    // list
    void append(int value)
    {
        // Create a new node
        Node* newNode = new Node(value);
        // If list is empty, set head and tail
        // to new node
        if (!head) {
            head = tail = newNode;
        }
        // Otherwise, append node to the end of the
        // list
        else {
            tail->next = newNode;
            newNode->prev = tail;
            tail = newNode;
        }
    }

    // Function to return iterator to the beginning of the
    // list
    DoublyLinkedListIterator begin()
    {
        return DoublyLinkedListIterator(head);
    }

    // Function to return iterator to the end of the list
    // (nullptr)
    DoublyLinkedListIterator end()
    {
        return DoublyLinkedListIterator(nullptr);
    }
};

int main()
{
    // Create a doubly linked list
    DoublyLinkedList list;

    // Append elements to the list
    list.append(10);
    list.append(20);
    list.append(30);

    // Iterate through the list using iterators and print
    // elements
    for (DoublyLinkedListIterator it = list.begin();
         it != list.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;

    return 0;
}