环形队列

需要用前几帧来估计当前丢失帧，所以需要缓冲区来存储前几帧

队列，先入先出，对不对

然后长度固定，环形队列对不对

头文件 BufferQueue.h

#define MAXSIZE_QUEUE 6

typedef struct
{
    float* buffer[MAXSIZE_QUEUE];
    int front,rear;
}BufferQueue;

BufferQueue * InitQueue();

void ClearQueue(BufferQueue * q);

int QueueEmpty(BufferQueue * q);

int QueueFull(BufferQueue * q);

void enQueue(BufferQueue * q,float *e,int SizeBuffer);

void deQueue(BufferQueue * q);

void TraverseQueue(BufferQueue *q, int size);

源文件 BufferQueue.c

#include"BufferQueue.h"
#include<malloc.h>
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
BufferQueue * InitQueue()
{
    BufferQueue * q=(BufferQueue *)malloc(sizeof(BufferQueue));
    q->front = q->rear = 0;
    return q;
}

void ClearQueue(BufferQueue * q)
{
    int i=q->front;
    while(i!=(q->rear))
    {
		free(q->buffer[i]);
		i =  (i+1)%MAXSIZE_QUEUE;
    }
    free(q);
}

int QueueEmpty(BufferQueue * q)
{
    return(q->front==q->rear);
}

int QueueFull(BufferQueue * q)
{
    return((q->rear+1)%MAXSIZE_QUEUE==q->front);
}

void enQueue(BufferQueue * q,float *e,int SizeBuffer)
{
	if(QueueFull(q))
	{
		deQueue(q);
		printf("退栈\n");
	}
		
    q->buffer[q->rear] = (float *)malloc(sizeof(float)*SizeBuffer);
    // malloc
    //cur = q->buffer[q->rear];
    memcpy(q->buffer[q->rear],e, sizeof(float)*SizeBuffer);
    q->rear = (q->rear+1)%MAXSIZE_QUEUE;
}

//出队列，删除队首元素
void deQueue(BufferQueue * q)
{
   //float * cur = q->buffer[q->front];
    free(q->buffer[q->front]);
    q->front = (q->front+1)%MAXSIZE_QUEUE;
    //free
}

void TraverseQueue(BufferQueue *q, int size)
{
    int i=(q->front);
    printf("队中的元素是:\n");
    while(i!=(q->rear))
    {
		int j;
		for(j=0;j<size;j++)
		{
			printf("%f  ",q->buffer[i][j]);
		}	
       i =  (i+1)%MAXSIZE_QUEUE;
    }
    printf("\n");
}

主函数

#include<stdlib.h>
#include<stdio.h>
#include"BufferQueue.h"

#define SIZE 5

int main()
{
    int loop;
    BufferQueue *q = InitQueue();

    for(loop = 1;loop<= 10;loop++)
    {
		
        int i;
        float xnq[SIZE];
		printf("%d次\n",loop);
        for(i=0;i<SIZE;i++)
        {
            xnq[i]=loop+i+0.0;
			printf("xnq:%f\n",xnq[i]);
        }
		
		enQueue(q,xnq,SIZE);
		TraverseQueue(q,SIZE);
    }

	ClearQueue(q);


    return 0;
}

afterthought

额，大概是基础不咋的，指针仍然是个头疼的问题

队列里是指针数组，指针指向数据

所以需要动态分配内存，然后释放也是

遍历的时候条件

   int i=(q->front);
    printf("队中的元素是:\n");
    while(i!=(q->rear))
    {
		int j;
		for(j=0;j<size;j++)
		{
			printf("%f  ",q->buffer[i][j]);
		}	
       i =  (i+1)%MAXSIZE_QUEUE;
    }

缓冲区么，入队列是，要是满就出再进咯

就是这样