循环队列有关操作

在通信程序中，经常使用环形缓冲区作为数据结构来存放通信中发送和接收的数据。环形缓冲区是一个先进先出的循环缓冲区，可以向通信程序提供对缓冲区的互斥访问。

1、环形缓冲区的实现原理

环形缓冲区通常有一个读指针和一个写指针。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区中可写的缓冲区。通过移动读指针和写指针就可以实现缓冲区的数据读取和写入。在通常情况下，环形缓冲区的读用户仅仅会影响读指针，而写用户仅仅会影响写指针。如果仅仅有一个读用户和一个写用户，那么不需要添加互斥保护机制就可以保证数据的正确性。如果有多个读写用户访问环形缓冲区，那么必须添加互斥保护机制来确保多个用户互斥访问环形缓冲区。

图1、图2和图3是一个环形缓冲区的运行示意图。图1是环形缓冲区的初始状态，可以看到读指针和写指针都指向第一个缓冲区处；图2是向环形缓冲区中添加了一个数据后的情况，可以看到写指针已经移动到数据块2的位置，而读指针没有移动；图3是环形缓冲区进行了读取和添加后的状态，可以看到环形缓冲区中已经添加了两个数据，已经读取了一个数据

2、实例：环形缓冲区的实现

#include "stdafx.h"
#include <memory.h>

/*
1.对于可读可写的buffer操作都会用到环状buffer.
2.read,write的操作必须同步
3.对环状buffer的操作有:初始化,read,write,判断空,判断满,计算没有被
  读到的个数,计算剩余空间的个数等
4.在循环buffer中约定,初始化建空队列时,令front=rear=0,每当插入新的队列尾元素时,尾指针增1;
  每当删除队列头元素时,头指针增1.因此,在非空队列中,头指针始终指向队列头元素,而尾指针始终
  指向队列尾元素的下一个位置.
*/

#define MaxSize 10
#define elementsof(x_mac)    (sizeof(x_mac)/sizeof(x_mac[0]))

typedef struct RingBuffer
{
    int ReadPt;    /* 循环队列只能在队列头读操作 */
    int WritePt;/* 循环队列只能在队列尾写操作 */
    int DataQueue[MaxSize];
}RingBuffer;

void InitQueue       ( RingBuffer *Queue );
bool WriteQueue       ( RingBuffer *Queue,int inData );
bool ReadQueue       ( RingBuffer *Queue,int *outData );
bool IsFullQueue   ( RingBuffer *Queue );
bool IsEmptyQueue  ( RingBuffer *Queue );
int CalcNumNotRead ( RingBuffer *Queue );
int CalcNumRevSpace( RingBuffer *Queue );

/**************************************************
*Function:    InitQueue( RingBuffer *Queue )
*
*ShortDesc:    创建一个空队列
*
*Inputs:    循环队列地址
*
*Outputs:    void
*
*Returns:    void
*
*Authors:    qinzhi
*
*History:    2010-12-8 12:00
****************************************************/
void InitQueue( RingBuffer *Queue )
{
    Queue->ReadPt = Queue->WritePt = 0;
    for (int i = 0; i < MaxSize; i++ )
    {
        Queue->DataQueue[i] = 0;
    }
}
/**************************************************
*Function:    IsFullQueue(RingBuffer *Queue)
*
*ShortDesc:    判断队列是否是满
*
*Inputs:    循环队列地址
*
*Outputs:    void
*
*Returns:    bool
*
*Authors:    qinzhi
*
*History:    2010-12-8 12:00
****************************************************/
bool IsFullQueue( RingBuffer *Queue )
{
    /* 写指针+1等于读指针 */
    if ( (Queue->WritePt + 1) % MaxSize == Queue->ReadPt )
        return true;
    else
        return false;
}
/**************************************************
*Function:    IsEmptyQueue(RingBuffer *Queue)
*
*ShortDesc:    判断队列是否是空
*
*Inputs:    循环队列地址
*
*Outputs:    void
*
*Returns:    bool
*
*Authors:    qinzhi
*
*History:    2010-12-8 12:00
****************************************************/
bool IsEmptyQueue( RingBuffer *Queue )
{
    /* 读指针等于写指针 */
    if ( Queue->ReadPt == Queue->WritePt )
        return true;
    else
        return false;
}
/**************************************************
*Function:    WriteQueue( RingBuffer *Queue,int inData )
*
*ShortDesc:    向循环队列中写入数据
*
*Inputs:    循环队列地址,写入的数据
*
*Outputs:    void
*
*Returns:    bool
*
*Authors:    qinzhi
*
*History:    2010-12-8 12:00
****************************************************/
bool WriteQueue( RingBuffer *Queue,int inData )
{
    /* 判断是否是满 */
    if ( IsFullQueue( Queue ) )
        return false;
    else
    {
        Queue->DataQueue[Queue->WritePt] = inData;            //写入数据
        Queue->WritePt = ( Queue->WritePt + 1 ) % MaxSize;    //写指针加1
        return true;
    }
}
/**************************************************
*Function:    ReadQueue( RingBuffer *Queue,int OutData )
*
*ShortDesc:    从循环队列中读出数据
*
*Inputs:    循环队列地址
*
*Outputs:    读出的数据
*
*Returns:    bool
*
*Authors:    qinzhi
*
*History:    2010-12-8 12:00
****************************************************/
bool ReadQueue( RingBuffer *Queue,int *outData )
{
    /* 判断是否是空*/
    if ( IsEmptyQueue( Queue ) )
        return false;
    else
    {
        *outData = Queue->DataQueue[Queue->ReadPt];            //读出数据
        Queue->DataQueue[Queue->ReadPt] = 0;
        Queue->ReadPt = ( Queue->ReadPt + 1 ) % MaxSize;    //读指针加1
        return true;
    }
}

/**************************************************
*Function:    CalcNumNotRead( RingBuffer *Queue )
*
*ShortDesc:    计算没有被读到的个数
*
*Inputs:    循环队列地址
*
*Outputs:    void
*
*Returns:    int
*
*Authors:    qinzhi
*
*History:    2010-12-8 12:00
****************************************************/
int CalcNumNotRead( RingBuffer *Queue )
{
    return ( Queue->WritePt + MaxSize - Queue->ReadPt ) % MaxSize;
}

/**************************************************
*Function:    CalcNumRevSpace( RingBuffer *Queue )
*
*ShortDesc:    计算剩余空间个数(保留空间)
*
*Inputs:    循环队列地址
*
*Outputs:    void
*
*Returns:    int
*
*Authors:    qinzhi
*
*History:    2010-12-8 12:00
****************************************************/
int CalcNumRevSpace( RingBuffer *Queue )
{
    return MaxSize - CalcNumNotRead( Queue );
}
int _tmain(int argc, _TCHAR* argv[])
{
    RingBuffer Data;
    int temp;
    int buffer[10];

    /* 初始化循环队列 */
    InitQueue( &Data );
    temp = 100;
    memset(buffer,0,elementsof(buffer)*sizeof(int));

    /* 向队列中写入数据 */
    if ( !WriteQueue( &Data,temp ) )
        printf("Write data to RingBuffer failed\n");

    /* 重置temp */
    temp = 0;

    /* 从队列中读出数据 */
    if ( ReadQueue( &Data,&temp ) )
    {
        printf("The Raad data is %d\n",temp);
    }
    else
    {
        printf("Write data to RingBuffer failed");
    }

    /* 以下是假设操作,用于对于同步读写操作的扩展用 */
    InitQueue( &Data );
    /* 向buffer中写入5个数据 */
    for ( temp = 1; temp <= 5; temp++ )
    {
        WriteQueue( &Data,temp );    //写入5个数据
    }
    /* 从buffer中读取3个数据 */
    for ( int i = 0; i < 3; i++ )
    {
        ReadQueue( &Data,&buffer[i] );    //读出3个数据
    }
    /* 计算没有被读到的个数 */
    temp = CalcNumNotRead( &Data );
    /* 计算剩余空间个数 */
    temp = CalcNumRevSpace( &Data );

    getchar();
    return 0;
}