[嵌入式开发模块]环形缓冲区/循环队列 C语言实现

最新推荐文章于 2024-06-08 11:19:02 发布
置顶 最新推荐文章于 2024-06-08 11:19:02 发布
阅读量1.5w 收藏 60
点赞数 8
分类专栏： 数据结构与算法 c-c++ 嵌入式开发 文章标签： 数据结构 c语言 嵌入式开发 FIFO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lin_strong/article/details/73604561
版权

忙着毕设，很久没有写文章了，终于答辩完了，得了个校优秀毕业设计。毕设做的是个智能接口模块，用一周时间入门了，MC9S12XEP100的开发，又用一周时间入门了uC/OS-II嵌入式操作系统，在做毕设的过程中学到了很多，现在把一些工具发上来分享。

注： 这个实现已弃用，当然本身是没什么问题，还可以继续使用。最新实现请移步 https://blog.csdn.net/lin_strong/article/details/88236566

这里分享一个自己用纯C实现的环形缓冲区。环形缓冲区有很多作用，比如嵌入式中的通信可以用环形缓冲区作为信道，一个线程往里放字节，一个线程取字节进行处理，只要保证取的速度大于读的速度，就可以保证通信顺畅进行，不丢一个字节。
简要介绍：
环形缓冲区其实就是一个队列，里头的元素是先入先出的，但是因为其(逻辑上)是环形的，所以不需要像很多队列的实现那样在内部元素变动的时候需要移动内部剩下的元素。这样就使元素出队入队的时间复杂度只有O(1)。具体实现一般有链表和数组两种方法，当不能确定需要的缓冲区大小时使用链表较好，能确定时使用数组可以节省很多动态分配内存的开销。
在嵌入式开发中，一般不动态分配内存，而是使用静态分配的数组。所以这里我使用数组实现了环形缓冲区，为了能够在不同的程序中复用代码，使用结构体模拟了面向对象编程，这样就可以用一套代码管理不同的缓冲区了。
废话不多说，直接上代码。以下是.h 文件：

/*
*********************************************************************************************************
*
*
*                                       RingQueueStruct
*                                         环形队列结构
*
* File : RingQueue.h
* By   : Lin Shijun(http://blog.csdn.net/lin_strong)
* Date : 2018/02/23
* version: V1.2
* NOTE(s): 这段程序用来对一个给定的缓冲区进行模拟环形队列的管理
*                   程序本身不会自动分配缓冲区空间,用户需要自己负责分配空间,并且要保证不直接访问缓存区
*                   // 在某处分配内存空间
*                   RQTYPE buffer[BUFFER_SIZE];
*                   RING_QUEUE que,*ptr_que;
*                   unsigned char err;
*                   // 初始化
*                   ptr_que = RingQueueInit(&que,buffer,BUFFER_SIZE,&err);
*                   if(err == RQ_ERR_NONE  ){
*                     // 初始化成功,使用其他函数
*                   }
* History : 2017/04/25   the original version of RingQueueStruct.
*           2017/10/16   put functions used frequently,RingQueueIn and RingQueueOut, in non-banked address;
*                        modify single line function RingQueueIsEmpty and RingQueueIsFull to marco function;
*                        to get better efficiency.
*           2018/02/23   1.add the marco(RQ_ARGUMENT_CHECK_EN) to controll argument check so user can save 
*                          more code.
*                        2.add the ADDRESSING MODE so the buffer can be defined in banked addressing area.
*********************************************************************************************************
*/


#ifndef   RING_QUEUE_H
#define   RING_QUEUE_H

/*
********************************************************************************************
*                                   MISCELLANEOUS
********************************************************************************************
*/

#ifndef  FALSE
#define  FALSE    0
#endif

#ifndef  TRUE
#define  TRUE     1
#endif

/*
*********************************************************************************************************
*                                       ADDRESSING MODE 寻址模式
*********************************************************************************************************
*/

// uncomment the corresponding line to select the addressing mode to the buffer of RingQueue module.
// if you don't understand. Just use the extended addressing mode
// 取消对应行的注释以选择环形缓冲区模块访问缓冲区时使用的寻址方式
// 如果你不知道这是什么意思的话，那就用扩展寻址就行了，这是默认的方式

// extended addressing mode 扩展区寻址(默认)
#define RQ_ADDRESSING_MODE
// banked RAM addressing mode   RAM分页区寻址
//#define RQ_ADDRESSING_MODE __rptr
// global addressing mode   全局寻址
//#define RQ_ADDRESSING_MODE __far

/*
*********************************************************************************************************
*                                       CONFIGURATION  配置
*********************************************************************************************************
*/

#define RQ_ARGUMENT_CHECK_EN    TRUE     // TRUE: arguments will be checked, however,this will 
                                         //       cost a little code volume.

/*
*********************************************************************************************************
*                                        CONSTANTS     常量
*********************************************************************************************************
*/
#define   RQ_ERR_NONE                        0u

#define   RQ_ERR_POINTER_NULL                1u
#define   RQ_ERR_SIZE_ZERO                   2u

#define   RQ_ERR_BUFFER_FULL                 3u
#define   RQ_ERR_BUFFER_EMPTY                4u

#define   RQ_OPTION_WHEN_FULL_DISCARD_FIRST  0u       // discard the first element when ring buffer is full
#define   RQ_OPTION_WHEN_FULL_DONT_IN        1u       // discard new element when ring buffer is full
/*
*********************************************************************************************************
*                                    DATA TYPE    数据类型
*********************************************************************************************************
*/

// define the data type that stores in the RingQueue.       定义存在环形缓冲区内的数据的类型
typedef unsigned char RQTYPE;
typedef RQTYPE *RQ_ADDRESSING_MODE pRQTYPE;
typedef struct {
    unsigned short  RingBufCtr;              /* Number of characters in the ring buffer */
    unsigned short  RingBufSize;             /* Ring buffer Size */    
    pRQTYPE RingBufInPtr;                    /* Pointer to where next character will be inserted        */  
    pRQTYPE RingBufOutPtr;                   /* Pointer from where next character will be extracted     */  
    pRQTYPE RingBuf;                         /* Ring buffer array */  
    pRQTYPE RingBufEnd;                      /* Point to the end of the buffer */
} RING_QUEUE;

/*
*********************************************************************************************************
*                                  FUNCTION PROTOTYPES 函数原型
*********************************************************************************************************
*/

RING_QUEUE *RingQueueInit(RING_QUEUE *pQueue,pRQTYPE pbuf,unsigned short bufSize,unsigned char *perr);
#pragma CODE_SEG __NEAR_SEG NON_BANKED
unsigned short RingQueueIn(RING_QUEUE *pQueue,RQTYPE data,unsigned char option,unsigned char *perr);
RQTYPE RingQueueOut(RING_QUEUE *pQueue,unsigned char *perr);
#pragma CODE_SEG DEFAULT
short RingQueueMatch(RING_QUEUE *pQueue,pRQTYPE pbuf,unsigned short len);
void RingQueueClear(RING_QUEUE *pQueue);

/*
*********************************************************************************************************
*                                        RingQueueIsEmpty()
*
* Description :  whether the RingQueue is empty.   环形队列是否为空
*
* Arguments   :  pQueue  pointer to the ring queue control block;     指向环形队列控制块的指针
*
* Return      :  TRUE    the RingQueue is empty.
*                FALSE   the RingQueue is not empty.
* Note(s)     :
*********************************************************************************************************
*/

#define RingQueueIsEmpty(pQueue) ((pQueue)->RingBufCtr == 0)

/*
*********************************************************************************************************
*                                        RingQueueIsFull()
*
* Description : whether the RingQueue is full.    环形队列是否为空
*
* Arguments   : pQueue  pointer to the ring queue control block;   指向环形队列控制块的指针
*
* Return      : TRUE    the RingQueue is full.
*               FALSE   the RingQueue is not full.
* Note(s)     :
*********************************************************************************************************
*/

#define RingQueueIsFull(pQueue)  ((pQueue)->RingBufCtr >= (pQueue)->RingBufSize)

#endif

然后下面是.c文件。

/*
*********************************************************************************************************
*
*
*                                       RingQueueStruct
*                                         环形队列结构
*
* File : RingQueue.c
* By   : Lin Shijun(http://blog.csdn.net/lin_strong)
* Date : 2018/02/23
* version: V1.2 
* NOTE(s): 
*
* History : 2017/04/25   the original version of RingQueueStruct.
*           2017/10/16   put functions used frequently,RingQueueIn and RingQueueOut, in non-banked address;
*                        modify single line function RingQueueIsEmpty and RingQueueIsFull to marco function;
*                        to get better efficiency.
*           2018/02/23   1.add the marco(RQ_ARGUMENT_CHECK_EN) to controll argument check so user can save 
*                          more code.
*                        2.add the ADDRESSING MODE so the buffer can be defined in banked addressing area.
*********************************************************************************************************
*/

/*
*********************************************************************************************************
*                                     INCLUDES
*********************************************************************************************************
*/
#include "RingQueue.h"

/*
*********************************************************************************************************
*                                LOCAL FUNCTION DECLARATION
*********************************************************************************************************
*/

#if(RQ_ARGUMENT_CHECK_EN == TRUE)
  #define argCheck(cond,err,rVal)  if(cond) { *perr = (err); return (rVal); }
#else
  #define argCheck(cond,err,rVal)
#endif // of (SPI_ARGUMENT_CHECK_EN == TRUE)



/*
*********************************************************************************************************
*                                LOCAL FUNCTION DECLARE
*********************************************************************************************************
*/
#pragma CODE_SEG __NEAR_SEG NON_BANKED
// 内部使用，给定将给定指针在环形缓冲区内向前移动一步(到尾了会移回头)
static void _forwardPointer(RING_QUEUE *pQueue,pRQTYPE* pPointer);
#pragma CODE_SEG DEFAULT
/*
*********************************************************************************************************
*                                        RingQueueInit()
*
* Description : To initialize the ring queue.    初始化环形队列
*
* Arguments   : pQueue   pointer to the ring queue control block;     指向环形队列控制块的指针
*               pbuf     pointer to the buffer(an array);             指向自定义的缓冲区(实际就是个数组)
*               bufSize  the Size of the buffer;                      缓冲区的大小;
*               perr     a pointer to a variable containing an error message which will be set by this
*                          function to either:
*
*                           RQ_ERR_NONE                                       
*                           RQ_ERR_SIZE_ZERO
*                           RQ_ERR_POINTER_NULL
*
* Return      : the pointer to the ring queue control block;        返回指向环形队列控制块的指针
*               0x00 if any error;                                  如果出错了则返回NULL
*
*Note(s):
*********************************************************************************************************
*/

RING_QUEUE* RingQueueInit(RING_QUEUE *pQueue,pRQTYPE pbuf,unsigned short bufSize,unsigned char *perr){
  argCheck(pQueue == 0x00 || pbuf == 0x00,RQ_ERR_POINTER_NULL,0x00);
  argCheck(bufSize == 0,RQ_ERR_SIZE_ZERO,0x00);
  pQueue->RingBufCtr = 0;
  pQueue->RingBuf = pbuf;
  pQueue->RingBufInPtr = pbuf;
  pQueue->RingBufOutPtr = pbuf;
  pQueue->RingBufSize = bufSize;
  pQueue->RingBufEnd = pbuf + bufSize;
  *perr = RQ_ERR_NONE;     
  return pQueue;
}

/*
*********************************************************************************************************
*                                        RingQueueIn()
*
* Description : Enqueue an element.    入队一个元素
*
* Arguments   : pQueue   pointer to the ring queue control block;    指向环形队列控制块的指针
*               data     the data to enqueue;                        要入队的数据
*               option   option when queue is full ,you can choose:  当队列满的时候的选项,你可以选择:
*                            RQ_OPTION_WHEN_FULL_DISCARD_FIRST          抛弃队头的元素来填进去新的元素
*                            RQ_OPTION_WHEN_FULL_DONT_IN                不入队新给的元素
*               perr     a pointer to a variable containing an error message which will be set by this
*                          function to either:
*
*                             RQ_ERR_NONE                            if no err happen
*                             RQ_ERR_POINTER_NULL                    if pointer is 0x00
*                             RQ_ERR_BUFFER_FULL                     if buffer is full
*
* Return       : the Elements Count after enqueue the element
*                    调用函数后队列中的元素个数
*Note(s)       :
*********************************************************************************************************
*/
#pragma CODE_SEG __NEAR_SEG NON_BANKED
unsigned short RingQueueIn(RING_QUEUE *pQueue,RQTYPE data,unsigned char option,unsigned char *perr){
  argCheck(pQueue == 0x00,RQ_ERR_POINTER_NULL,0x00);
  if(pQueue->RingBufCtr >= pQueue->RingBufSize){
    *perr = RQ_ERR_BUFFER_FULL;     
    if(option == RQ_OPTION_WHEN_FULL_DISCARD_FIRST){
      _forwardPointer(pQueue,&pQueue->RingBufOutPtr); /* Wrap OUT pointer                          */  
    }else{                                            // option == RQ_OPTION_WHEN_FULL_DONT_IN
      return pQueue->RingBufCtr;
    }
  }else{
    pQueue->RingBufCtr++;                             /* No, increment character count            */      
    *perr = RQ_ERR_NONE;
  }
  *pQueue->RingBufInPtr = data;                       /* Put character into buffer                */  
  _forwardPointer(pQueue,&pQueue->RingBufInPtr);      /* Wrap IN pointer                          */  
  return pQueue->RingBufCtr;
}
/*
*********************************************************************************************************
*                                        RingQueueOut()
*
* Description : Dequeue an element.       出队一个元素
*
* Arguments   : pQueue   pointer to the ring queue control block;     指向环形队列控制块的指针
*               perr     a pointer to a variable containing an error message which will be set by this
*                          function to either:
*
*                              RQ_ERR_NONE                            if no err happen
*                              RQ_ERR_POINTER_NULL                    if pointer is 0x00
*                              RQ_ERR_BUFFER_EMPTY                    if buffer is empty
*
* Return      : 0                 if any error or the data is 0;
*               others            the data 
*               
*Note(s):
*********************************************************************************************************
*/
RQTYPE RingQueueOut(RING_QUEUE *pQueue,unsigned char *perr){
  RQTYPE data;
  argCheck(pQueue == 0x00,RQ_ERR_POINTER_NULL,0x00);
  if(pQueue->RingBufCtr == 0){
    *perr = RQ_ERR_BUFFER_EMPTY;        
    return 0;
  }
  pQueue->RingBufCtr--;                                      /*  decrement character count           */  
  data = *pQueue->RingBufOutPtr;                      /* Get character from buffer                */  
  _forwardPointer(pQueue,&pQueue->RingBufOutPtr);        /* Wrap OUT pointer                          */  
  *perr = RQ_ERR_NONE;
  return data;
}
#pragma CODE_SEG DEFAULT
/*
*********************************************************************************************************
*                                        RingQueueMatch()
*
* Description : Match the given buffer in RingQueue          在环形队列中匹配给定缓冲区
*
* Arguments   : pQueue   pointer to the ring queue control block;     指向环形队列控制块的指针
*               pbuf     pointer to the chars need to match;
*               len      the length of the chars
* Return      :  -1       Don't match            -1    则没有匹配到
*                >= 0     match                  >= 0  则匹配到了
*
*Note(s):
*********************************************************************************************************
*/

short RingQueueMatch(RING_QUEUE *pQueue,pRQTYPE pbuf,unsigned short len){
  pRQTYPE pPosQ,pCurQ,pCurB,pEndB;
  unsigned short rLen,Cnt;
  if(len > pQueue->RingBufCtr)
    return -1;
  pPosQ = pQueue->RingBufOutPtr;
  pEndB = pbuf + len;
  Cnt = 0;
  rLen = pQueue ->RingBufCtr;
  while(rLen-- >= len){          // if remian length of queue bigger than buffer. continue
    pCurQ = pPosQ;
    pCurB = pbuf;
    while(pCurB != pEndB && *pCurQ == *pCurB) {    // compare one by one,until match all(pCurB==pEndB) or some one don't match
      _forwardPointer(pQueue,&pCurQ);
      pCurB++;
    }
    if(pCurB == pEndB)                                                 // if match all
       return Cnt;
     Cnt++;
     _forwardPointer(pQueue,&pPosQ);
  }
  return -1;
}

/*
*********************************************************************************************************
*                                        RingQueueClear()
*
* Description:  Clear the RingQueue.        清空环形队列
*
* Arguments  :  pQueue    pointer to the ring queue control block;     指向环形队列控制块的指针
*
* Return:             
*
* Note(s):
*********************************************************************************************************
*/

void RingQueueClear(RING_QUEUE *pQueue){
#if(RQ_ARGUMENT_CHECK_EN == TRUE)
  if(pQueue == 0x00)
    return;
#endif
  pQueue->RingBufCtr = 0;
  pQueue->RingBufInPtr = pQueue -> RingBufOutPtr;
}

/*
*********************************************************************************************************
*                                       LOCAL FUNCTION 
*********************************************************************************************************
*/

#pragma CODE_SEG __NEAR_SEG NON_BANKED
static void _forwardPointer(RING_QUEUE *pQueue,pRQTYPE* pPointer){
  if (++*pPointer == pQueue->RingBufEnd)   
    *pPointer = pQueue->RingBuf;        /* Wrap OUT pointer                          */  
}
#pragma CODE_SEG DEFAULT

简单解释下。在.h文件中定义了一个环形缓冲区的控制块，当然也可以当其为一个环形缓冲区对象，用户需要为每个环形缓冲区分配一个控制块和其缓冲区(也就是一个数组)。理想情况下，虽然用户知道控制块的结构，但也不应该直接访问内部字段，而应该通过提供的函数来访问。
队列中默认的元素是无符号字符，如果要改成缓存其他类型的话改下.h文件中的
typedef unsigned char RQTYPE;
这行就行了。
使用示例：

#include "RingQueue.h"
#define RX_BUF_MAX_SIZE     200        // 定义缓冲区的最大大小为200
static unsigned char RxBuffer[RX_BUF_MAX_SIZE];   // 定义缓冲区
static RING_QUEUE RxRingQ;             // 定义环形缓冲区的控制块
void main(){
   unsigned char err;
   // 初始化缓冲区
   RingQueueInit(&RxRingQ,RxBuffer,RX_BUF_MAX_SIZE,&err);
   if(err != RQ_ERR_NONE){
       //初始化缓冲区失败的处理
   }
   ……
}

然后调用所有方法都需要传递环形缓冲区控制块的指针。如入队就像：

// 往RxRingQ缓冲区内入队一个元素c，如果满的话丢弃第一个元素
RingQueueIn(&RxRingQ,c,RQ_OPTION_WHEN_FULL_DISCARD_FIRST,&err);

出队就像：

// 从RxRingQ缓冲区内提取一个字符
c = RingQueueOut(&RxRingQ,&err);

其他就不一 一举例了。要特别说明下的是RingQueueMatch()这个方法并不是队列应该有的方法，这是为了比如我需要在缓冲区中匹配到某一串字符后做某些事情而特别加上的，不需要的话删掉即可。比如我需要一旦出现“abc”就做某些事情，那我代码可以类似这么写：

static const unsigned char* StringsWait = "abc";
……
while(true){
    //比如从某处获得了下一个字符c
    ……
    // 将字符c入队
    RingQueueIn(&RxRingQ,c,RQ_OPTION_WHEN_FULL_DISCARD_FIRST,&err); 
    if(RingQueueMatch(&RxRingQ,StringsWait,3) >= 0){  // 如果在缓冲区内找到"abc"
         // RingQueueClear(&RxRingQ);     // 可能需要清空缓冲区
         // 做想要做的事
         ……
    }
}

有什么建议或意见请留言，谢谢！

更改历史：

2017/10/27 更新到 V1.1
2018/02/23 更新到 V1.2
2019/03/06 更改缓冲区实现方式，此版本弃用。

夏日白云
关注
  • 8
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
基于C语言实现一个循环缓冲区
03-05 1252
由于嵌入式系统的资源受限性，在大多数项目中都可以找到循环缓冲区数据结构。循环缓冲区（也称为环形缓冲区）是固定大小的缓冲区，就好像内存在本质上是连续的和循环的一样。随着内存的生成和消耗，数据不需要重新洗牌——而是调整头/尾指针。添加数据时，头指针前进。当数据被消费时，尾指针前进。如果到达缓冲区的末尾，指针将简单地环绕到开头。循环缓冲区通常用作固定大小的队列。固定大小有利于嵌入式系统，因为开发人员经常尝试使用静态数据存储方法而不是动态分配。
队列(queue)环形缓冲区(ring buffer)，环形队列(ring queue)
dianqicyuyan的博客
02-11 3784
什么是环形缓冲区？想要学会环形队列，你是不是得先学习一下队列？？？（如何在程序中实现队列？） 如何在代码中实现环形缓冲区？ 环形缓冲区适用于甚麽样的场合？ 环形缓存区： 环形缓冲器（ringr buffer），也称作圆形队列（circular queue），循环缓冲区（cyclic buffer），圆形缓冲区（circula buffer），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。 背景： 当有大量数据的时候，我们不能存储所有的数据，那么计算机处理数据的时候，只能先处理先来的
什么是循环缓冲区？
最新发布
weixin_49007164的博客
06-08 958
循环缓冲区（Circular Buffer），又称为环形缓冲区（Ring Buffer）或循环队列（Circular Queue），是一种有效的数据结构，用于管理固定大小的数据存储空间。它通过将缓冲区的末尾连接到起始位置形成一个闭合的环，来实现数据的循环存取。这种结构允许在有限的内存空间内高效地处理数据流动，而不需要频繁的内存分配或复制操作。
Java的循环队列(环形缓冲、RingBuffer)
学一次的博客
05-05 1796
RingBuffer好处线程安全，可以边写边读。 创建一个循环队列（环形缓冲、RingBuffer），实际元素存在一个数组中，操作数组的指针，不移动元素。
C语言实现循环缓冲区（环形缓冲区）
Linda的博客
01-11 985
C语言实现循环缓冲区
圆环填充c语言编程,环形缓冲区（ring buffer）实现原理及代码实现（C语言）
weixin_33796891的博客
05-20 983
0x00前言文章中的文字可能存在语法错误以及标点错误，请谅解；如果在文章中发现代码错误或其它问题请告知，感谢！运行环境：Linux version 2.6.35-22-generic (buildd@rothera) (gcc version 4.4.5 (Ubuntu/Linaro 4.4.4-14ubuntu4) )0x01环形缓冲区简介环形缓冲区(ring buffer)也称作循环缓冲区(c...
C#环形缓冲区（队列）完全实现
09-01
环形缓冲区（Ring Buffer），又称为循环缓冲区或环形队列，是一种高效的数据结构，常用于实时数据处理和通信系统中。它的主要特点是利用数组的线性空间，形成一个首尾相连的先进先出（FIFO）队列。在C#中，环形缓冲...
xqueue：基于C语言实现的循环队列缓冲区
04-09
根据提供的链接，`xqueue`是一个用C语言实现的循环队列缓冲区。这个库可能包含以下关键组成部分： 1. **队列结构定义**：通常包括一个固定大小的数组，用于存储数据，以及两个指针，分别指向队头和队尾。 2. **...
详解数据结构C语言实现之循环队列
09-01
在C语言中，实现循环队列通常涉及定义一个结构体来存储队列的属性，包括存储元素的数组、队头指针`front`、队尾指针`rear`以及队列的最大容量`maxsize`。 1. 循环队列基础： - 参数：循环队列需要两个关键参数，即...
C 语言中实现环形缓冲区
09-02
环形缓冲区（Circular Buffer）是一种常见的数据结构，常用于多线程通信、硬件中断处理等场景，它利用数组或内存空间的一段连续区域构建一个循环的数据队列。在C语言中实现环形缓冲区需要考虑线程安全和数据一致性...
C语言实现使用静态数组实现循环队列源码.zip
11-13
本资源“C语言实现使用静态数组实现循环队列源码.zip”提供了使用C语言编写的静态数组循环队列的实现，非常适合初学者学习和理解这一概念。 循环队列的基本思想是将一个固定大小的数组看作一个首尾相连的环形结构。...
c语言数组实现环形缓冲区,[嵌入式开发模块]环形缓冲区/循环队列 C语言实现
weixin_35775446的博客
05-21 826
忙着毕设，很久没有写文章了，终于答辩完了，得了个校优秀毕业设计。毕设做的是个智能接口模块，用一周时间入门了，MC9S12XEP100的开发，又用一周时间入门了uC/OS-II嵌入式操作系统，在做毕设的过程中学到了很多，现在把一些工具发上来分享。这里分享一个自己用纯C实现的环形缓冲区。环形缓冲区有很多作用，比如嵌入式中的通信可以用环形缓冲区作为信道，一个线程往里放字节，一个线程取字节进行处理，只要保...
关于环形缓冲区的使用
u011569253的博客
05-11 2997
前一段时间在做视频接收的时候，自己写了一个很简单的环形缓冲区例子，参照了ffmpeg  AVFifoBuffer类，但是又简化了这个类，并增加一个内存映射链表，用来动态移动读指针。现在我来介绍一下具体原理。 其实环形缓冲区就是在最开始的时候申请一个大buffer，有一个读指针，一个写指针，随着数据写入和读取改变读写指针，具体分为三总情况：一、是读写速度差不多，这种情况比较简单。二、写的很快读的慢
环形缓冲区实现（C语言）
little_rookie__的博客
11-24 3320
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入
循环队列——实现ringbuffer为了多媒体数据缓存
STN_LCD的专栏
07-06 1678
http://blog.csdn.net/firehood_/article/details/6716357 版权声明：本文为博主原创文章，未经博主允许不得转载。         在WINCE开发中很多时候需要用到循环队列来缓存数据，比如在串口通信中，可以将接收到的数据流先缓存到循环队列中，然后再从循环队列中取出数据做下一步的处理。这样可以有效的避免解析数据
循环缓冲区的实现（纯C）
weixin_40882562的博客
08-11 2092
循环缓冲区的用途 循环缓冲区主要用在文件系统中，和FIFO队列进行互补，特点是读写指针互不干扰，适用于经典的生产者消费者问题,相关原理已有相关博主解释。 循环缓冲区的定义 struct TRingBuf { char *buf; char *end_pos_; char *read_pos_; char *write_pos_; //int data_siz...
c语言代码实现输入循环缓冲区问题,C语言——循环缓冲区
weixin_29118723的博客
05-20 681
最近在搞GSM模块，一个主要问题就是对于GSM接收数据的处理。而首先是把数据全部接收过来，搞了一个循环缓存区，感觉好可以。#define ZPC_Debug SEGGER_RTT_printf//#define ZPC_Debug(...)#define DATA_RECV_BUFF_LEN 8192 //循环缓冲区大小uint8_t gsm_recv_bu...
环形缓冲区
热门推荐
蜜汁程序员的博客
10-20 2万+
https://blog.csdn.net/p23onzq/article/details/80750745 .https://blog.csdn.net/blade2001/article/details/7094232/ 正在造轮子，同时不停地在找哪里有这个轮子 原因： 当有大量数据的时候，我们不能存储所有的数据，那么计算机处理数据的时候，只能先处理先来的，那么处理完后呢，就会把数据释...
循环队列实现高速缓存的读写
06-17 2886
// 循环队列实现高速缓存的读写// 教材上有对循环队列的讲解，不过头指针，尾指针重合的时候不好理解// 这里仿造标准库中的begin(),end()节点，使得头指针，为指针永远不重合，相对好理解点// 实现了对简单类型的数据的输入输出缓存，不支持CString，std::string等复杂类型，因为用的memcpy拷贝的数据templateclass CInputOutput
循环队列c语言代码实现
04-15
循环队列是一种常见的数据结构，它可以在固定大小的数组上实现队列的功能。下面是一个简单的C语言代码实现循环队列的示例： ```c #include <stdio.h> #define MAX_SIZE 5 typedef struct { int data[MAX_SIZE]; int front; int rear; } CircularQueue; void initQueue(CircularQueue *queue) { queue->front = -1; queue->rear = -1; } int isFull(CircularQueue *queue) { if ((queue->rear + 1) % MAX_SIZE == queue->front) { return 1; } return 0; } int isEmpty(CircularQueue *queue) { if (queue->front == -1 && queue->rear == -1) { return 1; } return 0; } void enqueue(CircularQueue *queue, int item) { if (isFull(queue)) { printf("Queue is full.\n"); return; } if (isEmpty(queue)) { queue->front = 0; queue->rear = 0; } else { queue->rear = (queue->rear + 1) % MAX_SIZE; } queue->data[queue->rear] = item; } int dequeue(CircularQueue *queue) { if (isEmpty(queue)) { printf("Queue is empty.\n"); return -1; } int item = queue->data[queue->front]; if (queue->front == queue->rear) { queue->front = -1; queue->rear = -1; } else { queue->front = (queue->front + 1) % MAX_SIZE; } return item; } void displayQueue(CircularQueue *queue) { if (isEmpty(queue)) { printf("Queue is empty.\n"); return; } int i = queue->front; printf("Queue: "); while (i != queue->rear) { printf("%d ", queue->data[i]); i = (i + 1) % MAX_SIZE; } printf("%d\n", queue->data[i]); } int main() { CircularQueue queue; initQueue(&queue); enqueue(&queue, 1); enqueue(&queue, 2); enqueue(&queue, 3); enqueue(&queue, 4); enqueue(&queue, 5); displayQueue(&queue); dequeue(&queue); dequeue(&queue); displayQueue(&queue); enqueue(&queue, 6); enqueue(&queue, 7); displayQueue(&queue); return 0; } ``` 这段代码实现了一个循环队列，使用了一个固定大小为5的数组来存储队列元素。其中，`initQueue`函数用于初始化队列，`isFull`函数用于判断队列是否已满，`isEmpty`函数用于判断队列是否为空，`enqueue`函数用于入队操作，`dequeue`函数用于出队操作，`displayQueue`函数用于打印队列中的元素。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值