正文：
.h
#ifndef __CIRCULAR_QUEUE_H__
#define __CIRCULAR_QUEUE_H__
#include "stdint.h"
#include "string.h"
#include "stdlib.h"
#define USEDYNAMICMEMALLOC 0 /*--使用动态内存--*/
#define STATICMEMSIZE 1000 /*--使用静态内存时，静态数组的大小--*/
typedef struct __CircularQueue
{
uint16_t fullQueueLen;
uint16_t queueLen;
uint16_t head;
uint16_t tail;
int16_t (*deQueue)(struct __CircularQueue*);
int16_t (*enQueue)(struct __CircularQueue*, uint8_t);
void (*priorityEnQueue)(struct __CircularQueue*, uint8_t);
#if USEDYNAMICMEMALLOC
uint8_t* queue;
#else
uint8_t queue[STATICMEMSIZE];
#endif
}CircularQueue_t;
/*-----函数声明-----*/
extern void CirQueueInit(CircularQueue_t* queue, uint16_t len);
#endif /*#ifndef __CIRCULAR_QUEUE_H__*/
.c
/*
说明：本文件为循环队列相关，对于循环队列 CircularQueue_t 定义的数据之前，必须
先对该数据进行初始化，否则队列中的很多成员的值是不确定的。
例如：定义一个循环队列: CircularQueue_t queue;
在对循环队列queue进行任何操作之前，必须先初始化: CirQueueInit(&queue, 0);
否则程序必然跑飞。
<!!重要>：在对循环队列进行任何操作之前，必须先初始化
<!!重要>：在对循环队列进行任何操作之前，必须先初始化
<!!重要>：在对循环队列进行任何操作之前，必须先初始化
说明：循环队列中预留了5个位置用于优先入队
*/
#include "circular_queue.h"
#include <stdio.h>
static int16_t deQueue(CircularQueue_t* queue);
static int16_t enQueue(CircularQueue_t* queue, uint8_t element);
static void priorityEnQueue(CircularQueue_t* queue, uint8_t element);
/*-------------------------------------------------------------
@>功能：初始化一个循环队列
@>参数：len为使用动态内存时的指定参数，指定动态内存总大小
若使用静态内存，len值任意，一般指定为0
---------------------------------------------------------------*/
void CirQueueInit(CircularQueue_t* queue, uint16_t len)
{
#if USEDYNAMICMEMALLOC
queue->queue = (uint8_t*)malloc(len);
queue->fullQueueLen = len;
#else
queue->fullQueueLen = STATICMEMSIZE;
#endif
queue->deQueue = deQueue;
queue->enQueue = enQueue;
queue->priorityEnQueue = priorityEnQueue;
queue->queueLen = 0;
queue->head = 0;
queue->tail = 0;
memset(queue->queue, 0, queue->fullQueueLen);
}
/*--出队，成功返回出队元素，失败返回-1--*/
static int16_t deQueue(CircularQueue_t* queue)
{
uint8_t retval;
if(!queue->queueLen)
{
printf("出队失败，队列空\r\n");
return -1;
}
else
{
retval = queue->queue[queue->head++];
if(queue->head > queue->fullQueueLen - 1)
{
queue->head = 0;
queue->queue[queue->fullQueueLen - 1] = 0;
}
else
{
queue->queue[queue->head - 1] = 0;
}
queue->queueLen--;
return retval;
}
}
/*--入队，成功返回0，失败返回-1--*/
static int16_t enQueue(CircularQueue_t* queue, uint8_t element)
{
if(queue->fullQueueLen - queue->queueLen <= 5) /*--程序会至少在队列中留5个位置用于优先入队---*/
{
printf("非优先入队失败，队列已满\r\n");
return -1;
}
if(queue->tail > queue->fullQueueLen - 1)
{
queue->queue[0] = element;
queue->tail = 1;
}
else
{
queue->queue[queue->tail++] = element;
}
queue->queueLen++;
return 0;
}
/*--优先入队，插入队首---*/
static void priorityEnQueue(CircularQueue_t* queue, uint8_t element)
{
if(queue->fullQueueLen - queue->queueLen > 0)
{
queue->head--;
if(queue->head > queue->fullQueueLen)
{
queue->head = queue->fullQueueLen - 1;
}
queue->queueLen++;
queue->queue[queue->head] = element;
return;
}
printf("优先入队失败，队列已满\r\n");
}
创建和使用：
/*---NAND指令队列---*/
static CircularQueue_t NAND_InstQue;
static CircularQueue_t NAND_ParaByte1Que;
static CircularQueue_t NAND_ParaByte2Que;
static CircularQueue_t NAND_ParaByte3Que;
/*---宏函数：入队一条指令及其参数---*/
#define MacroNandEnQue(w,x,y,z) NAND_InstQue.enQueue(&NAND_InstQue, (w)); \
NAND_ParaByte1Que.enQueue(&NAND_ParaByte1Que, (x)); \
NAND_ParaByte2Que.enQueue(&NAND_ParaByte2Que, (y)); \
NAND_ParaByte3Que.enQueue(&NAND_ParaByte3Que, (z))
/*---宏函数：出队一条指令及其参数---*/
#define MacroNandDeQue(w,x,y,z) (w) = NAND_InstQue.deQueue(&NAND_InstQue); \
(x) = NAND_ParaByte1Que.deQueue(&NAND_ParaByte1Que); \
(y) = NAND_ParaByte2Que.deQueue(&NAND_ParaByte2Que); \
(z) = NAND_ParaByte3Que.deQueue(&NAND_ParaByte3Que)
/*---宏函数：初始化NAND队列---------*/
#define MacroNandQueInit() CirQueueInit(&NAND_InstQue, 0); \
CirQueueInit(&NAND_ParaByte1Que, 0); \
CirQueueInit(&NAND_ParaByte2Que, 0); \
CirQueueInit(&NAND_ParaByte3Que, 0)
