基于数组循环队列实现可拓展多条队列的处理

数组循环队列不懂的请自己百度，关于这方面的知识有很多，我这里重点将拓展。

也许很多人会问为什么不用链表，有如下原因：

• 使用系统自带的malloc和free对于有些单片机来讲，堆区并不完全能释放，除非自己实现内存管理。
• 由于单片机队列处理在中断中，如果没有互斥，一不小心就会导致指针指向出现问题。
• 内存分配是需要时间的

这也就是为什么单片机中都市使用数组实现的队列来做处理居多，而不要链表。如果你觉得你够强，不怕出问题当然也是可以使用的。

主要是看上图圈起的位置，利用这个指针指向外部的不同数组，就可以实现同时处理多条队列。剩下的知识就是循环队列的知识了，你就可以明白下面的实现原理了。

/*
 * app_que.h
 *  
*/
#ifndef APP_QUE_H
#define APP_QUE_H


typedef struct 
{
	unsigned char* rx_data;
	unsigned char front;
	unsigned char rear;
}que_t;


void app_in_que(que_t queue*, unsigned char val, unsigned char queue_length);
unsigned char app_out_que(que_t* queue, unsigned char *val, unsigned char queue_length);

#endif

/*
 *  app_que.c
 *
*/

#include "app_que.h"


unsigned char app_que_is_empty(que_t* queue)
{
	if (queue->front == queue->rear)
	{
		return 1;
	}
	return 0;
}
void app_in_que(que_t* queue, unsigned char val, unsigned char queue_length)
{
	if (queue->front == (queue->rear + 1) % queue_length)
	{
		queue->rx_data[queue->rear] = val;
		queue->rear = queue->front;
		queue->front = (queue->front + 1) % queue_length;
	}
	else
	{
		queue->rx_data[queue->rear] = val;
		queue->rear = (queue->rear + 1) % queue_length;		
	}

}
unsigned char app_out_que(que_t* queue, unsigned char *val, unsigned char queue_length)
{
	if (app_que_is_empty(queue))
	{
		return 1;
	}
	else
	{
		*val = queue->rx_data[queue->front];
		queue->front = (queue->front + 1) % queue_length;
	}
	return 0;
}

#include "app_que.h"


unsigned char uart_rx[10] = {0};//先定义一个数组,作为队列缓存
unsigned char mes[10] = {0};

que_t uart_que = {uart_rx, 0, 0};//定义出这个队列，使指针指向定义的数组
que_t mes_que = {mes, 0, 0};

void in_handler(void)
{
    val = 1;
    app_in_que(&uart_que, val, 10)
    app_in_que(&mes_que , val, 10)
}

void out_handler(void)
{
	unsigned char val = 0;
	
	if(app_out_que(&uart_que, &val, 10))//如果为真,则队列为空
	{
		return;
	}
	if（val == 1)
    {
	    //do  something
	}
    app_out_que(&uart_que, &val, 10)
}

道友请留步，在下看道友似乎另有想法，不妨说出来我等一起探讨一番。