环形队列 - c语言实现

本文包含了三个文件
1. loopqueue.c //环形链表的C语言
2. loopqueue.h //环形链表的头文件
3. main.c //测试代码

loopqueue.c

#include "stdlib.h"
#include "loopQueue.h"
#include "stdio.h"


typedef struct{
    char *buf;
    char head;
    char tail;
    uint32 size;
    uint32 capacity;
}LoopQueue_Handle_T;

PUBLIC LP_HANDLE loopQueue_create(uint32 len){
    LoopQueue_Handle_T* handle = (LoopQueue_Handle_T*)malloc(sizeof(LoopQueue_Handle_T));
    if(!handle){
        printf("loopQueue out of memory\n");
        return SCI_FALSE;
        }

    handle->buf = (char*)malloc(len);
    if(!handle->buf){
        printf("loopQueue out of memory\n");
        return SCI_FALSE;
        }

    handle->tail=0;
    handle->head=0;
    handle->size=0;
    handle->capacity = len;

    return (LP_HANDLE)handle;
}

PUBLIC void loopQueue_delete(LP_HANDLE handle){
    LoopQueue_Handle_T *lp_ptr = (LoopQueue_Handle_T *)handle;

    if(!lp_ptr) 
        return;
    free(lp_ptr->buf);
    free(lp_ptr);
}
//½«len³¤µÄbuf¼ÓÈëµ½lpÖÐ
PUBLIC int loopQueue_push(const LP_HANDLE handle,char *buf,uint32 len){
    uint32 i;
    LoopQueue_Handle_T *lp_ptr = (LoopQueue_Handle_T *)handle;

    if((lp_ptr->size+len)>lp_ptr->capacity){
        printf("loopQueue overflow\n");
        return SCI_FALSE;
        }

    for(i=0;i<len;i++){
        lp_ptr->buf[(lp_ptr->tail+i)%lp_ptr->capacity]=buf[i];
        }

    lp_ptr->tail = (lp_ptr->tail+i)%lp_ptr->capacity;
    lp_ptr->size +=len;

    return SCI_TRUE;
}
//Ïû·Ñµôlen³¤µÄÊý¾Ý
PUBLIC int loopQueue_pop(const LP_HANDLE handle, uint32 len){
    LoopQueue_Handle_T *lp_ptr = (LoopQueue_Handle_T *)handle;  

    if(lp_ptr->size<len){
        printf("loopQueue demanding more than exists\n");
        return SCI_FALSE;
        }

    lp_ptr->head = (lp_ptr->head+len)%lp_ptr->capacity;
    lp_ptr->size -=len;

    return SCI_TRUE;
}
//²é¿´´Óhead¿ªÊ¼µÄlen³¤¶ÈµÄÄÚÈÝ£¬°ÑÕâЩÄÚÈݷŵ½bufÀïÃæ
PUBLIC int loopQueue_peek(const LP_HANDLE handle, char *buf, uint32 len){
    uint32 i;
    LoopQueue_Handle_T *lp_ptr = (LoopQueue_Handle_T *)handle;  

    if(lp_ptr->size<len){
        printf("loopQueue demanding more than exists\n");
        return SCI_FALSE;
        }

    for(i=0;i<len;i++){
        buf[i]=lp_ptr->buf[(lp_ptr->head+i)%lp_ptr->capacity];
    }

    return SCI_TRUE;
}
//ÅжÏLP_HANDLEÊDz»ÊÇÂúÁË
PUBLIC int loopQueue_isfull(const LP_HANDLE handle){
    LoopQueue_Handle_T *lp_ptr = (LoopQueue_Handle_T *)handle;  
    return (lp_ptr->capacity == lp_ptr->size);
}
//ÅжÏLP_HANDLEÊDz»ÊÇ¿ÕµÄ
PUBLIC int loopQueue_isempty(const LP_HANDLE handle){
    LoopQueue_Handle_T *lp_ptr = (LoopQueue_Handle_T *)handle;  

    return (lp_ptr->size==0);
}
//LP_HANDLEµÄ×ܵĴóС
PUBLIC int loopQueue_compacity(const LP_HANDLE handle){
    LoopQueue_Handle_T *lp_ptr = (LoopQueue_Handle_T *)handle;  
    return lp_ptr->capacity;
}
//LP_HANDLEµÄµ±Ç°Êý¾ÝÁ¿
PUBLIC int loopQueue_size(const LP_HANDLE handle){
    LoopQueue_Handle_T *lp_ptr = (LoopQueue_Handle_T *)handle;
    return lp_ptr->size;
}

loopqueue.h

#ifndef __LOOP_QUEUE_H
#define __LOOP_QUEUE_H

#define LP_HANDLE   void*
#define PUBLIC extern
#define uint32 unsigned int
#define SCI_FALSE 0
#define SCI_TRUE 1

PUBLIC LP_HANDLE loopQueue_create(uint32 len);
PUBLIC void loopQueue_delete(LP_HANDLE handle);
//½«len³¤µÄbuf¼ÓÈëµ½lpÖÐ
PUBLIC int loopQueue_push(const LP_HANDLE handle,char *buf,uint32 len);
//Ïû·Ñµôlen³¤µÄÊý¾Ý
PUBLIC int loopQueue_pop(const LP_HANDLE handle, uint32 len);
//²é¿´´Óhead¿ªÊ¼µÄlen³¤¶ÈµÄÄÚÈÝ£¬°ÑÕâЩÄÚÈݷŵ½bufÀïÃæ
PUBLIC int loopQueue_peek(const LP_HANDLE handle, char *buf, uint32 len);
//ÅжÏLP_HANDLEÊDz»ÊÇÂúÁË
PUBLIC int loopQueue_isfull(const LP_HANDLE handle);
//ÅжÏLP_HANDLEÊDz»ÊÇ¿ÕµÄ
PUBLIC int loopQueue_isempty(const LP_HANDLE handle);
//LP_HANDLEµÄ×ܵĴóС
PUBLIC int loopQueue_compacity(const LP_HANDLE handle);
//LP_HANDLEµÄµ±Ç°Êý¾ÝÁ¿
PUBLIC int loopQueue_size(const LP_HANDLE handle);

#endif

main.c

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "loopqueue.h"

#define TEST_BUF_SIZE 1000
#define TEST_QUEUE_SIZE 100
#define UNIT 50

int main(int argc, char **argv)
{
    char read_buf[UNIT];
    char buf[TEST_BUF_SIZE];
    int i;
    int in_counter=0;
    int out_counter=0;
    LP_HANDLE hd = loopQueue_create(TEST_QUEUE_SIZE);

    srand(time(NULL));

    if(!hd)
        return -1;

    for(i=0;i%0xff;
    }

    while(in_counterint ret;
        int in_size = (int)(rand()*UNIT/RAND_MAX);
        int out_size = (int)(rand()*UNIT/RAND_MAX);
        if((in_counter+in_size)>TEST_BUF_SIZE){
            in_size = TEST_BUF_SIZE - in_counter;
        }
        ret = loopQueue_push(hd,&buf[in_counter],in_size);
        if(ret==SCI_FALSE)
            printf("push fail in_counter=%d in_size=%d\n",in_counter,in_size);
        else
            in_counter +=in_size;

        if(out_size>loopQueue_size(hd)){
            out_size = loopQueue_size(hd);
        }
        ret = loopQueue_peek(hd,read_buf,out_size);
        if(ret == SCI_FALSE){
            printf("read fail out_size=%d\n",out_size);
        }else{
            for(i=0;iif(ch != (out_counter+i)%0xFF)
                {
                    assert(0);
                }
            }
            out_counter +=out_size;
        }

        ret = loopQueue_pop(hd,out_size);
        if(ret == SCI_FALSE){
            printf("pop fail out_size=%d\n",out_size);
        }
    }//while

    loopQueue_delete(hd);

    return 0;
}