How to create a circular linked list with helper methods in C++

struct Node {
    int data;      // Value of the node
    Node* next;    // Pointer to the next node
    // Constructor to initialize a node
    Node(int value) : data(value), next(nullptr) {}
};

class CircularLinkedList {
private:
    Node* head;   // Pointer to the first node in the circular linked list
    Node* tail;   // Pointer to the last node in the circular linked list
public:
    // Constructor
    CircularLinkedList() : head(nullptr), tail(nullptr) {
        // Initializes an empty list by setting head and tail to nullptr
    }
    // Destructor to clean up resources
    ~CircularLinkedList() {
        // Check if the list is not empty
        if (head != nullptr) {
            Node* current = head;  // Start at the head of the list
            Node* nextNode;
            // Traverse the circular linked list and delete each node
            do {
                nextNode = current->next;  // Store pointer to the next node
                delete current;            // Delete the current node
                current = nextNode;        // Move to the next node
            } while (current != head);     // Stop when we loop back to the head
        }
    }
    // Adds a new node with the specified value at the head of the list
    void AddToHead(int value);
    // Adds a new node with the specified value at the tail of the list
    void AddToTail(int value);
    // Displays the contents of the list, starting from the head
    void Display();
    // Finds and returns a pointer to the first node containing the specified value
    // Returns nullptr if the value is not found
    Node* Find(int value);
    // Removes the first node (head) from the list
    // Updates head and tail pointers to maintain the circular structure
    void RemoveHead();
    // Removes the last node (tail) from the list
    // Updates head and tail pointers to maintain the circular structure
    void RemoveTail();
    // Removes the first node containing the specified value
    // Preserves the circular structure after removal
    void RemoveByValue(int value);
};

void CircularLinkedList::AddToHead(int value) {
    // Create a new node with the given value
    Node* newNode = new Node(value);
    // Check if the list is empty
    if (head == nullptr) {
        // If empty, both head and tail point to the new node
        head = newNode;
        tail = newNode;
        // Since it's a circular linked list, the new node points back to itself
        newNode->next = head;
    } else {
        // If the list is not empty:
        // Set the new node's next pointer to the current head
        newNode->next = head;
        // Update the head pointer to the new node
        head = newNode;
        // Update the tail's next pointer to maintain the circular structure
        tail->next = head;
    }
}

void CircularLinkedList::AddToTail(int value) {
    // Create a new node with the given value
    Node* newNode = new Node(value);
    // Check if the list is empty
    if (head == nullptr) {
        // If empty, both head and tail point to the new node
        head = newNode;
        tail = newNode;
        // Since it's a circular linked list, the new node points back to itself
        newNode->next = head;
    } else {
        // If the list is not empty:
        // Set the current tail's next pointer to the new node
        tail->next = newNode;
        // Update the tail pointer to the new node
        tail = newNode;
        // Maintain the circular structure by pointing the new tail's next to the head
        tail->next = head;
    }
}

void CircularLinkedList::Display() {
    // Check if the list is empty
    if (head == nullptr) {
        // If empty, print a message and return
        std::cout << "List is empty." << std::endl;
        return;
    }
    // Start traversal from the head of the list
    Node* current = head;
    // Use a do-while loop to ensure every node is visited exactly once
    do {
        // Print the data of the current node
        std::cout << current->data << " ";
        // Move to the next node
        current = current->next;
    } while (current != head); // Stop when we return to the head node
    // Print a newline to finalize the output
    std::cout << std::endl;
}

Node* CircularLinkedList::Find(int value) {
    // Check if the list is empty
    if (head == nullptr) {
        // If the list is empty, return nullptr as no nodes exist
        return nullptr;
    }
    // Start traversal from the head of the list
    Node* current = head;
    // Use a do-while loop to traverse the circular linked list
    do {
        // Check if the current node's data matches the given value
        if (current->data == value) {
            // If a match is found, return the pointer to the current node
            return current;
        }
        // Move to the next node in the list
        current = current->next;
    } while (current != head); // Stop when we return to the head node
    // If the value is not found after traversing the list, return nullptr
    return nullptr;
}

void CircularLinkedList::RemoveHead() {
    // Check if the list is empty
    if (head == nullptr) {
        // If the list is empty, there is nothing to remove, so return
        return;
    }
    // Check if the list has only one node
    if (head == tail) {
        // If there is only one node, delete it
        delete head;
        // Set both head and tail to nullptr, marking the list as empty
        head = nullptr;
        tail = nullptr;
    } else {
        // If the list has more than one node:
        // Store the current head in a temporary pointer for deletion
        Node* temp = head;
        // Move the head pointer to the next node
        head = head->next;
        // Update the tail's next pointer to the new head, maintaining circular structure
        tail->next = head;
        // Delete the old head node to free memory
        delete temp;
    }
}

void CircularLinkedList::RemoveTail() {
    // Check if the list is empty
    if (head == nullptr) {
        // If the list is empty, there is nothing to remove, so return
        return;
    }
    // Check if the list has only one node
    if (head == tail) {
        // If there is only one node, delete it
        delete head;
        // Set both head and tail to nullptr, marking the list as empty
        head = nullptr;
        tail = nullptr;
    } else {
        // If the list has more than one node:
        // Start at the head of the list
        Node* current = head;
        // Traverse the list to find the second-to-last node
        while (current->next != tail) {
            current = current->next;
        }
        // Update the second-to-last node's next pointer to point to the head
        current->next = head;
        // Delete the current tail node to free memory
        delete tail;
        // Update the tail pointer to the second-to-last node
        tail = current;
    }
}

void CircularLinkedList::RemoveByValue(int value) {
    // Check if the list is empty
    if (head == nullptr) {
        // If the list is empty, there is nothing to remove, so return
        return;
    }
    // Check if the value is in the head node
    if (head->data == value) {
        // Use the RemoveHead method to handle removing the head node
        RemoveHead();
        return;
    }
    // Start traversal from the head
    Node* current = head;
    do {
        // Get a pointer to the next node
        Node* nextNode = current->next;
        // Check if the next node contains the value to be removed
        if (nextNode->data == value) {
            // Update the current node's next pointer to skip the node to be deleted
            current->next = nextNode->next;
            // Check if the node to be deleted is the tail
            if (nextNode == tail) {
                // Update the tail pointer to the current node
                tail = current;
            }
            // Delete the node containing the value
            delete nextNode;
            // Return after successfully removing the node
            return;
        }
        // Move to the next node in the list
        current = current->next;
    } while (current != head); // Stop when we loop back to the head
}