环形数据缓冲区的实现 --C语言版本

已于 2022-12-01 16:32:27 修改
阅读量987 收藏 11
点赞数 4
分类专栏： 工作经验总结 C/C++知识 文章标签： c语言 开发语言
于 2021-01-23 18:00:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41290252/article/details/113058051
版权

嵌入式编程 环形缓冲区 中断处理 数据读写 同步机制
关键词由CSDN通过智能技术生成

一、引言

在嵌入式编程中，我们可能经常需要用到缓冲区来对数据进行短暂的保存，大部分的嵌入式编程本人的做法都是将数据先放入缓冲区而不对数据进行实时的处理，而是将数据的处理放在另一个地方进行处理，这源于在嵌入式的编程中我们的数据来源大部分都是来自中断或者是回调中接收数据流，对于在中断中我只做数据的接收从而达到快速的离开中断的目的，对于数据的处理可以通过消息的机制通知处理机去处理。

如果觉得上面的想法不对，就当废话！这里也推荐大家这种做法，不喜忽喷，本人目前也是只菜鸟，欢迎大家对我所说的做法以及代码中的错误在评论区评论，我也将跟大家共同进步！

二、环形数据缓冲区的原理

环形缓冲区的实现原理

环形缓冲区通常有一个读指针和一个写指针。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区中可写的缓冲区。通过移动读指针和写指针就可以实现缓冲区的数据读取和写入。在通常情况下，环形缓冲区的读用户仅仅会影响读指针，而写用户仅仅会影响写指针。如果仅仅有一个读用户和一个写用户，那么不需要添加互斥保护机制就可以保证数据的正确性。如果有多个读写用户访问环形缓冲区，那么必须添加互斥保护机制来确保多个用户互斥访问环形缓冲区。
这里在网上盗张图方便大家理解：
在这里插入图片描述

代码通过struct data_ringbuffer对数据缓冲区的进行管理，write_index为写指针，read_index为读指针，这里存在一个问题就是当读指针和写指针相等时缓冲区为空还是满的问题，这就通过 read_mirror和write_mirror来区别，当read_mirror==write_mirror时缓冲区为空，当read_mirror != write_mirror时缓冲区为满。

/* ring buffer */
struct data_ringbuffer
{
    uint8 *buffer_ptr;
    uint16 read_mirror : 1;
    uint16 read_index : 15;
    uint16 write_mirror : 1;
    uint16 write_index : 15;
    uint16 buffer_size;
};

这里只简单介绍一下，对于想具体理解的原理可以去网上搜索其他关于缓冲区原理的帖子了解，小伙伴也可以自己阅读接下来代码，里面的注释也写明了做法，没啥难懂的地方。

三、源码

前面的东西可以说很废话，直接贴上代码！

  • data_ringbuffer.h
/**
  **********************************************************************************
  * @file    data_ringbuffer.h
  * @author  czw
  * @version 
  * @date    2021-01-23
  * @brief
	**********************************************************************************  
  * @attention 
  *
  */

#ifndef __DATA_RINGBUFFER_H
#define __DATA_RINGBUFFER_H

typedef unsigned char           uint8;
typedef signed char             int8;
typedef unsigned short          wchar;
typedef unsigned short int      uint16;
typedef signed short int        int16;
typedef unsigned int            uint32;
typedef signed int              int32;

typedef signed char 			int8_t;
typedef signed short int 		int16_t;
typedef signed int 				int32_t;
typedef unsigned char 			uint8_t;
typedef unsigned short int 		uint16_t;
typedef unsigned int 			uint32_t;

/**
 * @ingroup BasicDef
 *
 * @def DATA_ALIGN_DOWN(size, align)
 * Return the down number of aligned at specified width. RT_ALIGN_DOWN(13, 4)
 * would return 12.
 */
#define DATA_ALIGN_DOWN(size, align)      ((size) & ~((align) - 1))

/* DATA_ALIGN_SIZE*/
#define DATA_ALIGN_SIZE	4


/* ring buffer */
struct data_ringbuffer
{
    uint8 *buffer_ptr;
    uint16 read_mirror : 1;
    uint16 read_index : 15;
    uint16 write_mirror : 1;
    uint16 write_index : 15;
    /* as we use msb of index as mirror bit, the size should be signed and
     * could only be positive. */
    uint16 buffer_size;
};

enum data_ringbuffer_state
{
    DATA_RINGBUFFER_EMPTY,
    DATA_RINGBUFFER_FULL,
    DATA_RINGBUFFER_HALFFULL, /* half full is neither full nor empty */
};

/* 缓冲区初始化 */
void data_ringbuffer_init(struct data_ringbuffer *rb,uint8 *pool,uint16 size);
/* 缓冲区中填充指定数据长度的数据(当缓冲区空间小于待写入的数据长度事不覆盖缓冲区原有数据) */
uint16 data_ringbuffer_put(struct data_ringbuffer *rb,const uint8 *ptr,uint16 length);
/* 缓冲区中填充指定数据长度的数据(当缓冲区空间小于待写入的数据长度事覆盖缓冲区原有数据) */
uint16 data_ringbuffer_put_force(struct data_ringbuffer *rb,const uint8 *ptr,uint16 length);
/* 缓冲区中填充一个数据(当缓冲区空间小于待写入的数据长度事不覆盖缓冲区原有数据) */
uint16 data_ringbuffer_putchar(struct data_ringbuffer *rb, const uint8 ch);
/* 缓冲区中填充一个数据(当缓冲区空间小于待写入的数据长度事覆盖缓冲区原有数据) */
uint16 data_ringbuffer_putchar_force(struct data_ringbuffer *rb, const uint8 ch);
/* 缓冲区中获取指定长度的数据(返回实际获取数据的长度) */
uint16 data_ringbuffer_get(struct data_ringbuffer *rb,uint8 *ptr,uint16 length);
/* 缓冲区中获取一个数据(返回实际获取数据的长度) */
uint16 data_ringbuffer_getchar(struct data_ringbuffer *rb, uint8 *ch);

#endif
  • data_ringbuffer.c
/**
  **********************************************************************************
  * @file    data_ringbuffer.c
  
  * @author  czw
  * @version 
  * @date    2020-01-23
  * @brief
	**********************************************************************************  
  * @attention 
  *
  */
#include "data_ringbuffer.h"


/** return the size of empty space in rb */
#define data_ringbuffer_space_len(rb) ((rb)->buffer_size - data_ringbuffer_data_len(rb))


 /**
 ****************************************************************************************
 * @brief Initialization of the data buffer.
 *
 * @param[in] rb 	Pointer to a variable that manages the data buffer.
 * @param[in] pool 	A pointer to a data buffer.
 * @param[in] size 	Size of the data buffer.
 * @return 
 ****************************************************************************************
 */ 
void data_ringbuffer_init(struct data_ringbuffer *rb,
						  uint8           	   *pool,
                          uint16            	size)
{

    /* initialize read and write index */
    rb->read_mirror = rb->read_index = 0;
    rb->write_mirror = rb->write_index = 0;

    /* set buffer pool and size */
    rb->buffer_ptr = pool;
    rb->buffer_size = DATA_ALIGN_DOWN(size, DATA_ALIGN_SIZE);
}


/**
 ****************************************************************************************
 * @brief Get the data buffer state.
 *
 * @param[in] rb Pointer to a variable that manages the data buffer.
 * @return Returns the data buffer storage state.
 ****************************************************************************************
 */
enum data_ringbuffer_state data_ringbuffer_status(struct data_ringbuffer *rb)
{
    if (rb->read_index == rb->write_index)
    {
        if (rb->read_mirror == rb->write_mirror)
            return DATA_RINGBUFFER_EMPTY;
        else
            return DATA_RINGBUFFER_FULL;
    }
    return DATA_RINGBUFFER_HALFFULL;
}

 /**
 ****************************************************************************************
 * @brief Gets the size of the existing data in the data buffer.
 *
 * @param[in] Pointer to a variable that manages the data buffer.
 * @return Returns the size of the existing data in the data buffer (in bytes).
 ****************************************************************************************
 */ 
uint16 data_ringbuffer_data_len(struct data_ringbuffer *rb)
{
    switch (data_ringbuffer_status(rb))
    {
    case DATA_RINGBUFFER_EMPTY:
        return 0;
    case DATA_RINGBUFFER_FULL:
        return rb->buffer_size;
    case DATA_RINGBUFFER_HALFFULL:
    default:
        if (rb->write_index > rb->read_index)
            return rb->write_index - rb->read_index;
        else
            return rb->buffer_size - (rb->read_index - rb->write_index);
    };
}


 /**
 ****************************************************************************************
 * @brief  Put a block of data into ring buffer.
 *
 * @param[in] rb 	 Pointer to a variable that manages the data buffer.
 * @param[in] ptr 	 Pointer to the data to be written.
 * @param[in] length The length of the written data.
 * @return The length of the data actually written.
 ****************************************************************************************
 */ 
uint16 data_ringbuffer_put(struct data_ringbuffer *rb,
                           const uint8       	  *ptr,
                           uint16                 length)
{
    uint16 size = 0;

    /* whether has enough space */
    size = data_ringbuffer_space_len(rb);

    /* no space */
    if (size == 0)
        return 0;

    /* drop some data */
    if (size < length)
        length = size;
	/* One-time write */
    if (rb->buffer_size - rb->write_index > length)
    {
        /* read_index - write_index = empty space */
        memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
        /* this should not cause overflow because there is enough space for
         * length of data in current mirror */
        rb->write_index += length;
        return length;
    }
	/* two-time write */
    memcpy(&rb->buffer_ptr[rb->write_index],
           &ptr[0],
           rb->buffer_size - rb->write_index);
    memcpy(&rb->buffer_ptr[0],
           &ptr[rb->buffer_size - rb->write_index],
           length - (rb->buffer_size - rb->write_index));

    /* we are going into the other side of the mirror */
    rb->write_mirror = ~rb->write_mirror;
    rb->write_index = length - (rb->buffer_size - rb->write_index);

    return length;
}

 /**
 ****************************************************************************************
 * @brief  put a block of data into ring buffer. 
		   When the buffer is full,it will discard the old data.
 *
 * @param[in] rb 	 Pointer to a variable that manages the data buffer.
 * @param[in] ptr 	 Pointer to the data to be written.
 * @param[in] length The length of the written data.
 * @return The length of the data actually written.
 ****************************************************************************************
 */ 
uint16 data_ringbuffer_put_force(struct data_ringbuffer *rb,
								 const uint8     		*ptr,
								 uint16           		length)
{
    uint16 space_length = 0;

    space_length = data_ringbuffer_space_len(rb);

    if (length > space_length)
        length = rb->buffer_size;

    if (rb->buffer_size - rb->write_index > length)
    {
        /* read_index - write_index = empty space */
        memcpy(&rb->buffer_ptr[rb->write_index], ptr, length);
        /* this should not cause overflow because there is enough space for
         * length of data in current mirror */
        rb->write_index += length;

        if (length > space_length)
            rb->read_index = rb->write_index;

        return length;
    }

    memcpy(&rb->buffer_ptr[rb->write_index],
           &ptr[0],
           rb->buffer_size - rb->write_index);
    memcpy(&rb->buffer_ptr[0],
           &ptr[rb->buffer_size - rb->write_index],
           length - (rb->buffer_size - rb->write_index));

    /* we are going into the other side of the mirror */
    rb->write_mirror = ~rb->write_mirror;
    rb->write_index = length - (rb->buffer_size - rb->write_index);

    if (length > space_length)
    {
        rb->read_mirror = ~rb->read_mirror;
        rb->read_index = rb->write_index;
    }

    return length;
}

 /**
 ****************************************************************************************
 * @brief  put a character into ring buffer. 
 *
 * @param[in] rb 	 Pointer to a variable that manages the data buffer.
 * @param[in] ch 	 Written data.
 * @return The length of the data actually written.
 ****************************************************************************************
 */ 
uint16 data_ringbuffer_putchar(struct data_ringbuffer *rb, const uint8 ch)
{
    /* whether has enough space */
    if (!data_ringbuffer_space_len(rb))
        return 0;

    rb->buffer_ptr[rb->write_index] = ch;

    /* flip mirror */
    if (rb->write_index == rb->buffer_size-1)
    {
        rb->write_mirror = ~rb->write_mirror;
        rb->write_index = 0;
    }
    else
    {
        rb->write_index++;
    }

    return 1;
}

 /**
 ****************************************************************************************
 * @brief  put a character into ring buffer. 
 *		   When the buffer is full, it will discard one old data.
 * @param[in] rb 	 Pointer to a variable that manages the data buffer.
 * @param[in] ch 	 Written data.
 * @return The length of the data actually written.
 ****************************************************************************************
 */ 
uint16 data_ringbuffer_putchar_force(struct data_ringbuffer *rb, const uint8 ch)
{
    enum data_ringbuffer_state old_state;

    old_state = data_ringbuffer_status(rb);

    rb->buffer_ptr[rb->write_index] = ch;

    /* flip mirror */
    if (rb->write_index == rb->buffer_size-1)
    {
        rb->write_mirror = ~rb->write_mirror;
        rb->write_index = 0;
        if (old_state == DATA_RINGBUFFER_FULL)
        {
            rb->read_mirror = ~rb->read_mirror;
            rb->read_index = rb->write_index;
        }
    }
    else
    {
        rb->write_index++;
        if (old_state == DATA_RINGBUFFER_FULL)
            rb->read_index = rb->write_index;
    }

    return 1;
}

 /**
 ****************************************************************************************
 * @brief  Get data from ring buffer. 
 *
 * @param[in] rb 	 Pointer to a variable that manages the data buffer.
 * @param[in] ptr 	 Pointer to the read storage location.
 * @param[in] length The length of the Read data.
 * @return Get the length of the actual data.
 ****************************************************************************************
 */ 
 uint16 data_ringbuffer_get(struct data_ringbuffer *rb,
                            uint8           	   *ptr,
                            uint16           	   length)
{
    uint16 size = 0;

    /* The length of the existing data in the buffer */
    size = data_ringbuffer_data_len(rb);

    /* no data */
    if (size == 0)
        return 0;

    /* less data */
    if (size < length)
        length = size;

    if (rb->buffer_size - rb->read_index > length)
    {
        /* copy all of data */
        memcpy(ptr, &rb->buffer_ptr[rb->read_index], length);
        /* this should not cause overflow because there is enough space for
         * length of data in current mirror */
        rb->read_index += length;
        return length;
    }

    memcpy(&ptr[0],
           &rb->buffer_ptr[rb->read_index],
           rb->buffer_size - rb->read_index);
    memcpy(&ptr[rb->buffer_size - rb->read_index],
           &rb->buffer_ptr[0],
           length - (rb->buffer_size - rb->read_index));

    /* we are going into the other side of the mirror */
    rb->read_mirror = ~rb->read_mirror;
    rb->read_index = length - (rb->buffer_size - rb->read_index);

    return length;
}

 /**
 ****************************************************************************************
 * @brief  get a character from a ringbuffer. 
 *
 * @param[in] rb 	 Pointer to a variable that manages the data buffer.
 * @param[in] ch 	 Pointer to the read storage location.
 * @return Get the length of the actual data.
 ****************************************************************************************
 */ 
uint16 data_ringbuffer_getchar(struct data_ringbuffer *rb, uint8 *ch)
{

    /* ringbuffer is empty */
    if (!data_ringbuffer_data_len(rb))
        return 0;

    /* put character */
    *ch = rb->buffer_ptr[rb->read_index];

    if (rb->read_index == rb->buffer_size-1)
    {
        rb->read_mirror = ~rb->read_mirror;
        rb->read_index = 0;
    }
    else
    {
        rb->read_index++;
    }

    return 1;
}

四、总结

上面的代码怎么用？
第一步就是初始化啦

struct data_ringbuffer DATA_RINGBUFF;
uint8       Receive_buf[256];
data_ringbuffer_init(&DATA_RINGBUFF,Receive_buf,sizeof(Receive_buf));

接着就是调入写数据以及取数据函数

/* 缓冲区中填充指定数据长度的数据(当缓冲区空间小于待写入的数据长度事不覆盖缓冲区原有数据) */
uint16 data_ringbuffer_put(struct data_ringbuffer *rb,const uint8 *ptr,uint16 length);
/* 缓冲区中获取指定长度的数据(返回实际获取数据的长度) */
uint16 data_ringbuffer_get(struct data_ringbuffer *rb,uint8 *ptr,uint16 length);

另外还提供了对于写数据和读数据的其他函数具体可以查看头文件对函数的说明。
数据接收有了，对于数据的解析处理如状态机，流处理等笔者学习完，下次有时间再写一篇出来，欢迎关注，交流学习，一枚小白的卑微请求！

小伙伴觉得可以的话就直接将代码加入进你们的工程中吧！也顺便麻烦点个赞收藏起来，拒绝伸手党好吧嘻嘻！

威威攻城狮
关注
专栏目录
环形缓冲区的应用ringbuffer
道亦无名
07-07 1万+
在通信程序中，经常使用环形缓冲区作为数据结构来存放通信中发送和接收的数据。环形缓冲区是一个先进先出的循环缓冲区，可以向通信程序提供对缓冲区的互斥访问。 1、环形缓冲区的实现原理 环形缓冲区通常有一个读指针和一个写指针。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区中可写的缓冲区。通过移动读指针和写指针就可以实现缓冲区的数据读取和写入。在通常情况下，环形缓冲区的读用户仅仅会影响读指针，而
环形缓冲区C语言实现
技术联盟
01-12 3180
////////////////////////////////////////////////////////////////////////////////// typedef unsigned char u8; typedef unsigned int u32; #define BUFFER_SIZE (1024*500) //缓冲区的长度,可以修改 static u32 vali...
C语言实现环形缓冲区
m0_49476241的博客
09-01 3810
本篇文章将为大家介绍一下什么是环形缓冲区，在很多场合都可以使用环形缓冲区，他既可以进行数据的写入也可以进行数据的读取，使用环形缓冲区可以减小数据丢失的风险，更加保证了数据的安全性和有效性。在通信程序中，经常使用环形缓冲器作为数据结构来存放通信中发送和接收的数据。环形缓冲区是一个先进先出的循环缓冲区，可以向通信程序提供对缓冲区的互斥访问。环形缓冲区在嵌入式开发中会经常使用到，我希望大家能够将这个知识点牢记于心。...
环形缓冲区实现（C语言）
little_rookie__的博客
11-24 3693
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入
环形缓冲区的C语言实现
qq_30309813的博客
02-17 1219
什么是唤醒缓冲区？ 环形缓冲器（ringr buffer），也称作圆形队列（circular queue），循环缓冲区（cyclic buffer），圆形缓冲区（circula buffer），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。 PS：概念就直接抄百度百科了，这没啥好说的 图也直接百度抄了，博主太懒了emm 本文主要讲下如何实现环形缓冲区发送数据 ...
C 语言中实现环形缓冲区
09-02
总结来说，C语言实现环形缓冲区的关键在于理解其工作原理，即如何在有限的存储空间中实现数据的循环读写，以及在多线程环境下如何使用同步机制确保数据一致性。具体实现包括： 1. 定义环形缓冲区的数据结构，包括...
C语言实现循环缓冲区（环形缓冲区）
01-11
循环缓冲区，也称为环形缓冲区，是计算机科学中一种高效的数据结构，常用于处理实时数据流。在C语言中实现循环缓冲区涉及到内存管理、数据读写以及线程安全等多个方面。以下是对这个主题的详细阐述： 一、概念理解 ...
c语言数组实现环形缓冲区,[嵌入式开发模块]环形缓冲区/循环队列 C语言实现
weixin_35775446的博客
05-21 866
忙着毕设，很久没有写文章了，终于答辩完了，得了个校优秀毕业设计。毕设做的是个智能接口模块，用一周时间入门了，MC9S12XEP100的开发，又用一周时间入门了uC/OS-II嵌入式操作系统，在做毕设的过程中学到了很多，现在把一些工具发上来分享。这里分享一个自己用纯C实现的环形缓冲区。环形缓冲区有很多作用，比如嵌入式中的通信可以用环形缓冲区作为信道，一个线程往里放字节，一个线程取字节进行处理，只要保...
无锁循环缓冲区的实现c语言,C++ 无锁环形缓冲区实现
weixin_35403151的博客
05-20 603
前段时间有个项目要实现一个基于live555的rtspserver，部分功能要用到环形缓冲区，网上看了一些blog，大部分是实验性质的，不太敢用，原理比较简单，所以就自己写了一个；实现环形缓冲区的关键点：1. 一个线程读，一个线程写2. 读线程维护读指针，写线程维护写指针3.数据一致性3.1 写线程写数据时，要先确定读指针；读线程读数据时，要先确定写指针；这里写的可能比较拗口，其实就是 写线程写...
C语言环形缓冲区
最新发布
m0_48995611的博客
06-21 833
本文提供一种C语言环形缓冲区的实现方法。
C语言实现环形缓存区
qq_37830757的博客
03-30 1827
感谢最好的涛提供的源码：https://blog.csdn.net/maowentao0416/article/details/81984269 本文在此基础上整理记录。 环形缓冲区 一、环形缓冲区的特性 1、先进新出 2、当缓冲区被使用完，且又有新的数据需要存储时，丢掉历史最久的数据，保存最新数据 现实中的存储介质都是线性的...
环形缓冲区（c语言）
qq_45570844的博客
02-28 940
C语言环形缓冲区
环形缓冲区的实现原理（ring buffer）
热门推荐
blade2001的专栏
12-22 3万+
消息队列锁调用太频繁的问题算是解决了，另一个让人有些苦恼的大概是这太多的内存分配和释放操作了。频繁的内存分配不但增加了系统开销，更使得内存碎片不断增多，非常不利于我们的服务器长期稳定运行。也许我们可以使用内存池，比如SGI STL中附带的小内存分配器。但是对于这种按照严格的先进先出顺序处理的，块大小并不算小的，而且块大小也并不统一的内存分配情况来说，更多使用的是一种叫做环形缓冲区的方案，mango
C语言构建环形缓冲区
Leon的博客
08-29 6798
它逻辑上是一个首尾相连的FIFO结构，具体实现上采用简单的线性数组。通过额外的辅助标志（head、tail）能很快知道队列的使用情况（是满还是为空）。正因为其简单高效的原因，甚至在硬件都实现了环形队列。 环形队列广泛用于网络数据收发、程序间的大量数据交换（比如内核与应用程）、硬件接收大量数据。 1、环形缓冲区原理 环列队列逻辑上将数组元素array[0]与array[LEN-1]连接起来，形成一个存放队列的环形空间。实际操作中为了方便读写，采用head和tail分别指向可以读的位置和可以写的位置。 环形
C语言--环形缓存区
有人住高楼，有人在深沟；有人光万丈，有人一身锈。
08-03 4373
环形缓冲区最重要的一个特点是写的速度和读的速度匹配性问题，环形缓冲区一般是将数据先写入缓冲区内，然后有个写的指针位置，但是不能超过读的位置，因为数据还未被读取，便写入数据，就会造成数据还未被读取便被新的数据覆盖，造成数据的丢失。读数据同样原理，读的指针不能超过写的位置，这样就会读到之前读过的数据，造成数据的重复。空间如果设置的太大，会造成内存的浪费，有内存一直处于空闲状态，如果空间设置到的太小，可能会造成读的速度快于写的速度，导致读的过程中会有短暂的等待时间，造成效率不是最高。2、写入数据>缓冲区。....
C语言简单实现环形缓冲及验证
cwj1112的专栏
07-27 1195
最近发现，无论是底层还是上层，亦或是CPU运行，都离不开缓存（广义的），缓存的最大用处当然是缓存数据，同时还有一大用处就是隔离功能模块，这对于软件的模块化来说实在太有意义了。环形缓冲作为一个工具类模块，在项目中其实一直在使用，不过其实现是其他大佬实现的，功能完善且强大，今天突然心血来潮，想按自己的理解实现一下，加深一下对其的理解。这里引用百度百科环形缓冲百度百科。......
C语言实战：环形缓冲区的实现
junhua的博客
04-06 555
环形缓冲区可以运用的地方有很多，在数据有多个输入源的情况下，可以杜绝得多个输入相互掩盖掉的情况。 /* 环形缓冲区 */ #define BUF_LEN 128 //环形缓冲区长度 static int g_keys[BUF_LEN]; static int r, w; #define NEXT_POS(x) ((x+1) % BUF_LEN) //判断是否为空 static int is_key_buf_empty(void) { return (r == w); } //判断是否为满 stati
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

威威攻城狮

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值