设计一个带头尾指针的循环单链表，头指针front，尾指针rear，模拟队列，给出入队出队代码

设计一个带头尾指针的循环单链表作为队列，首先需要定义节点结构，并创建两个指针front（队首）和rear（队尾）。在这种数据结构中，当我们向队列添加元素（入队）时，将新节点插入到rear之后；移除元素（出队）时，从front指向的节点开始。

// 定义链表节点结构
struct Node {
    int data;
    Node* next;
};

class CircularQueue {
private:
    Node* front; // 队首指针
    Node* rear; // 队尾指针
    int capacity; // 链表容量

public:
    // 构造函数，初始化容量
    CircularQueue(int size) : front(nullptr), rear(nullptr), capacity(size) {}

    // 入队操作
    void enqueue(int value) {
        if (isFull()) {
            throw std::overflow_error("Queue is full");
        }
        Node* newNode = new Node{value, front};
        
        if (!front) { // 如果队空，front和rear都指向newNode
            front = rear = newNode;
        } else {
            rear->next = newNode;
            rear = newNode;
            rear->next->next = front; // 形成环形结构
        }
    }

    // 出队操作
    int dequeue() {
        if (isEmpty()) {
            throw std::underflow_error("Queue is empty");
        }
        int removedValue = front->data;

        if (front == rear) { // 队列只有一个元素
            Node* temp = front;
            front = rear = nullptr;
            delete temp;
        } else {
            front = front->next;
            rear->next = front; // 更新队尾指针
        }
        return removedValue;
    }

    // 判断队列是否为空
    bool isEmpty() const {
        return front == nullptr;
    }

    // 判断队列是否满
    bool isFull() const {
        return rear == front + (capacity - 1); // 因为是循环队列，所以 rear + 1 可能等于 front
    }
    
    // 获取队列长度
    int size() const {
        if (isEmpty()) {
            return 0;
        } else if (front == rear) {
            return 1; // 单一元素的情况
        } else {
            int count = 1;
            Node* current = front;
            while (current != rear) {
                count++;
                current = current->next;
            }
            return count;
        }
    }
};