C语言创建一个泛型队列

队列用的挺多的. 这里备份一个. 这代码是人工智能写的. 挺好.

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define QUEUE_SIZE 10  // 定义队列的大小

// 定义队列中的元素
typedef struct {
    
    
    void *data;  // 用 void * 存储泛型元素
    size_t size;  // 存储元素的大小
} QueueElement;

// 定义队列
typedef struct {
    
    
    QueueElement *elements;  // 存储队列中的元素
    size_t size;  // 存储队列的大小
    size_t front;  // 存储队列的头
    size_t rear;  // 存储队列的尾
} Queue;

// 创建队列
Queue *createQueue(size_t size) {
    
    
    Queue *queue = (Queue *) malloc(sizeof(Queue));  // 为队列分配内存
    queue->elements = (QueueElement *) malloc(sizeof(QueueElement) * size);  // 为队列中的元素分配内存
    queue->size = size;  // 存储队列的大小
    queue->front = 0;  // 初始化队列的头
    queue->rear = 0;  // 初始化队列的尾
    return queue;  // 返回队列
}

// 判断队列是否为空
bool isQueueEmpty(Queue *queue) {
    
    
    return queue->front == queue->rear;  // 判断队列的头是否等于队列的尾
}

// 判断队列是否已满
bool isQueueFull(Queue *queue) {
    
    
    return (queue->rear + 1) % queue->size == queue->front;  // 判断队列的尾是否等于队列的头的前一个位置
}

// 入队
bool enqueue(Queue *queue, void *data, size_t size) {
    
    
    if (isQueueFull(queue)) {
    
      // 判断队列是否已满
        return false;  // 如果队列已满，返回 false
    }
    QueueElement *element = &(queue->elements[queue->rear]);  // 获取队列的尾元素
    element->data = malloc(size);  // 为元素的数据分配内存
    if (element->data == NULL) {
    
      // 判断内存是否分配成功
        return false;  // 如果内存分配失败，返回 false
    }
    element->size = size;  // 存储元素的大小
    memcpy(element->data, data, size);  // 将元素的数据复制到队列中
    queue->rear = (queue->rear + 1) % queue->size;  // 将队列的尾指针向后移动
    return true;  // 入队成功，返回 true
}

// 出队
bool dequeue(Queue *queue, void *data, size_t size) {
    
    
    if (isQueueEmpty(queue)) {
    
      // 判断队列是否为空
        return false;  // 如果队列为空，返回 false
    }
    QueueElement *element = &(queue->elements[queue->front]);  // 获取队列的头元素
    memcpy(data, element->data, size);  // 将元素的数据复制到 data 中
    free(element->data);  // 释放元素的数据的内存
    element->data = NULL;  // 将元素的数据的指针指向 NULL
    element->size = 0;  // 将元素的大小设置为 0
    queue->front = (queue->front + 1) % queue->size;  // 将队列的头指针向后移动
    return true;  // 出队成功，返回 true
}

// 销毁队列
void destroyQueue(Queue *queue) {
    
    
    while (!isQueueEmpty(queue)) {
    
      // 循环直到队列为空
        QueueElement *element = &(queue->elements[queue->front]);  // 获取队列的头元素
        free(element->data);  // 释放元素的数据的内存
        element->data = NULL;  // 将元素的数据的指针指向 NULL
        element->size = 0;  // 将元素的大小设置为 0
        queue->front = (queue->front + 1) % queue->size;  // 将队列的头指针向后移动
    }
    free(queue->elements);  // 释放队列中元素的内存
    queue->elements = NULL;  // 将队列中元素的指针指向 NULL
    queue->size = 0;  // 将队列的大小设置为 0
    queue->front = 0;  // 将队列的头指针设置为 0
    queue->rear = 0;  // 将队列的尾指针设置为 0
    free(queue);  // 释放队列的内存
}

// 示例程序
int main() {
    
    
    Queue *queue = createQueue(QUEUE_SIZE);  // 创建队列
    int intData = 1;  // 定义 int 类型的数据
    enqueue(queue, &intData, sizeof(int));  // 将 int 类型的数据入队
    intData = 2;  // 定义 int 类型的数据
    enqueue(queue, &intData, sizeof(int));  // 将 int 类型的数据入队
    intData = 3;  // 定义 int 类型的数据
    enqueue(queue, &intData, sizeof(int));  // 将 int 类型的数据入队
    intData = 0;  // 定义 int 类型的数据
    while (dequeue(queue, &intData, sizeof(int))) {
    
      // 循环直到队列为空
        printf("%d ", intData);  // 输出队列中的元素
    }
    destroyQueue(queue);  // 销毁队列
    return 0;  // 返回 0
}

在这个示例代码中，我们定义了两个结构体，QueueElement 用于存储队列中的元素，Queue 用于存储队列的元素和队列的状态。我们使用了 void *data 来存储泛型元素，size_t size 来存储元素的大小。我们使用了两个指针，front 和 rear，来指示队列的头和尾。我们使用了两个函数，isQueueEmpty 和 isQueueFull，来判断队列是否为空或已满。我们使用了四个函数，createQueue，enqueue，dequeue，和 destroyQueue，来创建队列，入队，出队，和销毁队列。我们使用了一个示例程序来演示如何使用队列。