C语言构建环形缓冲区

最新推荐文章于 2024-07-09 15:15:27 发布
最新推荐文章于 2024-07-09 15:15:27 发布
阅读量6.5k 收藏 93
点赞数 11
分类专栏： 嵌入式开发 c 文章标签： c语言 数据结构 FIFO 环形缓冲区
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangzc1124/article/details/119975372
版权
本文详细介绍了环形队列的概念、结构及其在数据收发、程序间数据交换等场景中的应用。文中提供了两种实现方式：一种是预留1个空位，另一种是通过附加满空标志位。每种实现包括数据结构、操作规则、函数接口以及测试案例。此外，还讨论了getchar()与输入缓冲区的关系。
摘要由CSDN通过智能技术生成

它逻辑上是一个首尾相连的FIFO结构，具体实现上采用简单的线性数组。通过额外的辅助标志（head、tail）能很快知道队列的使用情况（是满还是为空）。正因为其简单高效的原因，甚至在硬件都实现了环形队列。

环形队列广泛用于网络数据收发、程序间的大量数据交换（比如内核与应用程）、硬件接收大量数据。

1、环形缓冲区原理

image-20210828164243830

  • 环列队列逻辑上将数组元素array[0]与array[LEN-1]连接起来，形成一个存放队列的环形空间。实际操作中为了方便读写，采用head和tail分别指向可以读的位置和可以写的位置。
  • 环形队列的关键是判断队列为空，还是为满。一般有两种方法：
    • 一是附加一个标志位tag
    • 当head赶上tail，队列空，则令tag=0
    • 当tail赶上head，队列满，则令tag=1
    • 二是在队尾结点与队首结点之间留有1个元素的空间
      • 队列空： head==tail
      • 队列满： (tail+1)% MAXN ==head

2、预留1个空位的环形队列

  • 开始时head和tail指向同一个地址，但随着数据的push和poll，head和tail之间永远预留一个单元空间。如下图所示即为一个满队列。但箭头所指的位置不准确。tail应该指向空位，head指向9。即从头出去，从尾巴进来。

image-20210828164743425

  • 数据结构：
struct ring_queue{  
    unsigned int head;   
    unsigned int tail;  
    unsigned int size; 	//环形缓冲区容量
    int *array;   		//实际缓冲区（数组）的首地址
};
  • 规则：
    • head指向可读位置（地址存有数据），tail指向可写位置（地址无数据）。
    • 初始化状态: head = tail = 0;
    • 判定队列为空：head == tail
    • 队列为满：**（ (tail+1) % SIZE ) == head **
    • 入队操作：若队列不满，则写入。
    • 出队操作：若队列不空，则读出。
    • 缓冲区必须是连续的内存空间，可以通过静态数组变量或局部数组变量的方式定义，但绝不能从堆上分配（malloc），因为malloc分配的内存空间是不连续的！！！
  • 头文件：
#ifndef __RINGQ_H__
#define __RINGQ_H__

#ifdef __cplusplus
extern "C" {
#endif

    
typedef struct {  
    unsigned int head;   
    unsigned int tail;
    unsigned int size;
    int *array;   
}RINGQ;    

#define ringq_is_empty(q) (q->head == q->tail)
#define ringq_is_full(q) (((q->tail+1)%q->size) == q->head )

int ringq_init(RINGQ * ringqp, int * array_ptr, unsigned size);
int ringq_free(RINGQ * ringqp);
int ringq_push(RINGQ * ringqp,int data);
int ringq_poll(RINGQ * ringqp,int * val);
void ringq_display(RINGQ * ringqp);

#ifdef __cplusplus
}
#endif

#endif
  • c文件：
  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include "ringq.h"
  4 
  5 int ringq_init(RINGQ * ringqp, int * array_ptr, unsigned size)
  6 {
  7     /*
  8        不能从堆里分配空间！！！
  9        因为堆里的空间不是连续的，而是通过链表链接的一个空间串
 10     if(!(ringqp->array = (int *)malloc(size))){
 11         printf("Malloc failed!\n");
 12        return -1;
 13     }
 14     */
 15     ringqp->array = array_ptr;
 16     ringqp->size = size;
 17     ringqp->head = 0;
 18     ringqp->tail = 0;
 19     return 0;
 20 }
 21 
 22 int ringq_free(RINGQ * ringqp)
 23 {
 24     free(ringqp->array);
 25     return 0;
 26 }
 27 
 28 
 29 int ringq_push(RINGQ * ringqp,int data)
 30 {
 31     if(ringq_is_full(ringqp))
 32     {
 33         printf("ringq is full.\n");
 34         return -2;
 35     }
 36     ringqp->array[ringqp->tail] = data;
 37     ringqp->tail = (ringqp->tail + 1) % ringqp->size ;
 38     return 0;
 39 }
 40 
 41 
 42 int ringq_poll(RINGQ * ringqp,int * val)
 43 {
 44    if(ringq_is_empty(ringqp))
 45     {
 46         printf("ringq is empty.\n");
 47         return -3;
 48     }
 49     *val = ringqp->array[ringqp->head];
 50     ringqp->head = (ringqp->head + 1) % ringqp->size ;
 51     return 0;
 52 }
 53 
 54 void ringq_display(RINGQ * ringqp)
 55 {
 56     int  i =0;
 57     unsigned head = ringqp->head;
 58     unsigned tail = ringqp->tail;
 59     unsigned size = ringqp->size;
 60 
 61     if(ringq_is_empty(ringqp))
 62     {
 63         printf("ringq is empty.\n");
 64         return;
 65     }
 66     while(head != tail){
 67         printf("%04d ",ringqp->array[head]);
 68         i++;
 69         if(i == 5){
 70             printf("\n");
 71             i = 0;
 72         }
 73         head = (head + 1)%(size);
 74     }
 75     printf("\n");
 76     return;
 77 }
  • 测试文件：
  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include "ringq.h"
  4 
  5 #define RQ_SIZE 50 
  6 
  7 int main(void)
  8 {
  9     int data_in = 0;
 10     int data_out = 0;
 11     int select = 0;
 12 
 13     int array[RQ_SIZE]={};
 14     RINGQ rq, *rqp;
 15     rqp = &rq;
 16 
 17     ringq_init(rqp, array, RQ_SIZE);
 18     ringq_display(rqp);
 19 
 20     int index = RQ_SIZE - 1;    //allways a bank between head and tail
 21     while (index > 0){
 22         ringq_push(rqp,1);
 23         index -= 1;
 24     }
 25 
 26     ringq_display(rqp);
 27 
 28     while (index < RQ_SIZE-1){
 29         ringq_poll(rqp,&data_out);
 30         index += 1;
 31     }
 32 
 33     ringq_display(rqp);
 34 
 35     while (index > 0){
 36         ringq_push(rqp,2);
 37         index -= 1;
 38     }
 39 
 40     ringq_display(rqp);
 41     
 42    return 0;
 43 }
  • 实验结果：

image-20210828223651731

  • 测试文件2
  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include "ringq.h"
  4 
  5 #define RQ_SIZE 5 
  6 
  7 int main(void)
  8 {
  9     int data_in = 0;
 10     int data_out = 0;
 11     int select = 0;
 12 
 13     int array[RQ_SIZE]={};
 14     RINGQ rq, *rqp;
 15     rqp = &rq;
 16 
 17     ringq_init(rqp, array, RQ_SIZE);
 18     ringq_display(rqp);
 19       
 42 
 43 loop:  puts("push or poll or quit? [i/o/q]");
 44     select = getchar();
 45     getchar();  //丢弃回车
 46     switch(select){
 47         case 'i':
 48             printf("The push data is:");
 49             scanf("%d",&data_in);
 50             getchar();  //丢弃回车
 51             ringq_push(rqp, data_in);
 52             break;
 53         case 'o':
 54             ringq_poll(rqp, &data_out);
 55             printf("%d poll successfull.\n",data_out);
 56             break;
 57         case 'q':
 58             
 59             return 0;
 60         default:
 61             printf("Wrong choice!enter i or o!\n");
 62     }
 63     ringq_display(rqp);
 64     printf("\n");
 65     goto loop;
 66 }
  • 实验结果：

image-20210828224608118

image-20210828224656414

3、附加满空标志位的环形队列

  • 数据结构
typedef struct ringq{
   int head;
   int tail;
   int tag ;
   int size ;
   int space[RINGQ_MAX];

}RINGQ;
  • 规则
    • 初始化状态: q->head = q->tail = q->tag = 0;
    • 队列为空:(q->head == q->tail) && (q->tag == 0)
    • 队列为满**: ((q->head == q->tail) && (q->tag == 1))**
    • 入队操作:如队列不满，则写入q->tail = (q->tail + 1) % q->size ;
    • 出队操作：如果队列不空，则从head处读出。下一个可读的位置在 q->head = (q->head + 1) % q->size
  • 头文件
#ifndef __RINGQ_H__
#define __RINGQ_H__

#ifdef __cplusplus
extern "C" {
#endif

#define QUEUE_MAX 20
typedef struct ringq{
   int head;
   int tail;
   int tag ;
    int size ;
   int space[QUEUE_MAX];
}RINGQ;


extern int ringq_init(RINGQ * p_queue);
extern int ringq_free(RINGQ * p_queue);
extern int ringq_push(RINGQ * p_queue,int data);
extern int ringq_poll(RINGQ * p_queue,int *p_data);
#define ringq_is_empty(q) ( (q->head == q->tail) && (q->tag == 0))
#define ringq_is_full(q) ( (q->head == q->tail) && (q->tag == 1))
#define print_ringq(q) printf("ring head %d,tail %d,tag %d\n", q->head,q->tail,q->tag);
#ifdef __cplusplus
}
#endif

#endif
  • 实现代码
#include <stdio.h>
#include "ringq.h"

int ringq_init(RINGQ * p_queue)
{
   p_queue->size = QUEUE_MAX ;
   p_queue->head = 0;
   p_queue->tail = 0;
   p_queue->tag = 0;
   return 0;
}

int ringq_free(RINGQ * p_queue)
{
    return 0;
}
//Write data to the queue
int ringq_push(RINGQ * p_queue,int data)
{
    print_ringq(p_queue);
    if(ringq_is_full(p_queue))
    {
        printf("ringq is full\n");
        return -1;
    }
    p_queue->space[p_queue->tail] = data;
    p_queue->tail = (p_queue->tail + 1) % p_queue->size ;
    if(p_queue->tail == p_queue->head)
    {
        p_queue->tag = 1;
    }
    return p_queue->tag ;
}
//Get data from the queue
int ringq_poll(RINGQ * p_queue,int * p_data)
{
    print_ringq(p_queue);
    if(ringq_is_empty(p_queue))
    {
        printf("ringq is empty\n");
        return -1;
    }
    *p_data = p_queue->space[p_queue->head];
    p_queue->head = (p_queue->head + 1) % p_queue->size ;
    if(p_queue->tail == p_queue->head)
    {
        p_queue->tag = 0;
    }
    return p_queue->tag ;
}
  • 测试代码
//请参考上节的test.c

参考资料：【转】环形队列理论（C语言） - 程序天空下的骆驼 - 博客园 (cnblogs.com)

Leon_George
关注
专栏目录
C语言--环形缓存区
有人住高楼，有人在深沟；有人光万丈，有人一身锈。
08-03 4217
环形缓冲区最重要的一个特点是写的速度和读的速度匹配性问题，环形缓冲区一般是将数据先写入缓冲区内，然后有个写的指针位置，但是不能超过读的位置，因为数据还未被读取，便写入数据，就会造成数据还未被读取便被新的数据覆盖，造成数据的丢失。读数据同样原理，读的指针不能超过写的位置，这样就会读到之前读过的数据，造成数据的重复。空间如果设置的太大，会造成内存的浪费，有内存一直处于空闲状态，如果空间设置到的太小，可能会造成读的速度快于写的速度，导致读的过程中会有短暂的等待时间，造成效率不是最高。2、写入数据>缓冲区。....
C语言环形缓冲区
03-10
C语言实现环形缓冲区，可供多线程读写操作
对免杀木马RingQ的分析、代码附在文中
最新发布
qq_49849300的博客
07-09 630
然后最近想找一些开源的免杀项目生成免杀马，就想起了这个项目该项目原理是先用create.exe将shellcode\exe转换成main.txt，然后用RingQ.exe加载main.txt进行上线。因为RingQ.exe是开源的，因此分析RingQ.exe的代码这里用到反沙箱，因为沙箱可能会跳过line257的sleep,通过这种方式规避沙箱。然后用xor解密，key是520520，然后直接写入内存执行了。https://github.com/T4y1oR/RingQ
【C语言】环形缓冲区
m0_61011506的博客
10-04 1185
文章目录一、环形缓冲区的特性二、算法说明三、代码示例 一、环形缓冲区的特性 1、先进新出 2、当缓冲区被使用完，且又有新的数据需要存储时，丢掉历史最久的数据，保存最新数据。 现实中的存储介质都是线性的，因此我们需要做一下处理，才能在功能上实现环形缓冲区。 这里写图片描述： 二、算法说明 1、pHead和pTail分别是连续存储介质的首地址和尾地址 2、pTail - pHead 的值是环形缓冲区的总长度 3、pValid 是使用区域的起始指针，取数据时的起点，当取数据时pValid要发生偏移 4、pVa
环形缓冲区实现（C语言）
little_rookie__的博客
11-24 3557
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入
C语言实战：环形缓冲区的实现
junhua的博客
04-06 535
环形缓冲区可以运用的地方有很多，在数据有多个输入源的情况下，可以杜绝得多个输入相互掩盖掉的情况。 /* 环形缓冲区 */ #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
C语言实现环形缓冲区
m0_49476241的博客
09-01 3754
本篇文章将为大家介绍一下什么是环形缓冲区，在很多场合都可以使用环形缓冲区，他既可以进行数据的写入也可以进行数据的读取，使用环形缓冲区可以减小数据丢失的风险，更加保证了数据的安全性和有效性。在通信程序中，经常使用环形缓冲器作为数据结构来存放通信中发送和接收的数据。环形缓冲区是一个先进先出的循环缓冲区，可以向通信程序提供对缓冲区的互斥访问。环形缓冲区在嵌入式开发中会经常使用到，我希望大家能够将这个知识点牢记于心。...
环形缓冲区的C语言实现
qq_30309813的博客
02-17 1197
什么是唤醒缓冲区？ 环形缓冲器（ringr buffer），也称作圆形队列（circular queue），循环缓冲区（cyclic buffer），圆形缓冲区（circula buffer），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。 PS：概念就直接抄百度百科了，这没啥好说的 图也直接百度抄了，博主太懒了emm 本文主要讲下如何实现环形缓冲区发送数据 ...
C：环形缓冲区的实现
FristLineCode的博客
07-21 525
C文件： /************************************************************* * @brief : 环形缓冲区设计,可移植任意C平台。 * @author : 萌哒兽 * @date : 2020-07-21(更新) * @note : 使用前调用 RingBuffInit(); 来初始化缓冲区。 *************************************************************/ #in
C 语言中实现环形缓冲区
09-02
环形缓冲区（Circular Buffer）是一种常见的数据结构，常用于多线程通信、硬件中断处理等场景，它利用数组或内存空间的一段连续区域构建一个循环的数据队列。在C语言中实现环形缓冲区需要考虑线程安全和数据一致性...
无锁 环形缓冲区
08-15
`ReadMe.txt`文件通常是项目说明或指南，可能包含了如何使用这个无锁环形缓冲区库的详细信息，包括如何构建、如何在代码中引入和使用，以及可能存在的限制和注意事项。 在实际应用中，无锁环形缓冲区可以用于各种...
22. USART_CircleBuffer 串口接收环形缓冲区
04-05
通过上述步骤，结合STM32的USART中断功能和环形缓冲区技术，我们可以构建一个高效、可靠的串口接收系统。这种方案不仅可以减少CPU的实时性负担，还能提高系统的响应速度，适用于各种需要实时处理串口数据的场景。 ...
环形缓冲区_环形buffer_
10-03
这个源代码可能包含了结构体定义、初始化函数、读写操作函数、状态检查函数以及可能的同步控制机制，这些都是构建和使用环形缓冲区的关键组成部分。通过对源代码的分析和实践，你能够更好地掌握如何在自己的项目中...
基于C语言多个共享内存构成环形缓冲(操作系统实验)【100012384】
05-24
在本实验中，我们将深入探讨基于C语言的多进程通信技术，特别关注如何利用共享内存构建环形缓冲区。在操作系统领域，这种技术是进程间通信（IPC, Inter-Process Communication）的一种有效手段，用于协调不同进程...
环形缓冲区（c语言）
qq_45570844的博客
02-28 899
C语言环形缓冲区
环形缓冲区C语言实现
技术联盟
01-12 3153
////////////////////////////////////////////////////////////////////////////////// typedef unsigned char u8; typedef unsigned int u32; #define BUFFER_SIZE (1024*500) //缓冲区的长度,可以修改 static u32 vali...
C语言知识点 - 001：环形缓冲区Ring Buffer详细分析记录
梦想技术家
05-08 1371
称作，也称作环形队列（circular queue），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。如下为的概念示意图。在任务间的通信、串口数据收发、log缓存、网卡处理网络数据包、音频/视频流处理中均有的应用。在的和文件中，内核文件kfifo.h和kfifo.c中也有的代码实现。由于计算机内存是线性地址空间，因此需要特别的算法设计才可以从逻辑上实现。先不要想的具体实现细节，来看一个简单的例子。如下是一个空间大小为。
环形缓冲区c语言实现
09-14
环形缓冲区的C语言实现可以参考以下步骤： 首先，需要创建一个包含所需函数和变量声明的头文件。可以使用引用中提供的RingBuffer.h头文件作为起点。该头文件中定义了环形缓冲区所需的类型和函数声明。 接下来，在源代码文件中引用该头文件，并实现其中声明的函数。我们可以使用引用中提供的main.c代码作为参考。在代码中，可以看到头文件RingBuffer.h被引用，并且在代码中实现了InitRingBuffer、writeRingbuffer、readRingbuffer、releaseRingbuffer等函数。 在InitRingBuffer函数中，首先对环形缓冲区进行初始化。这个函数接受一个指向缓冲区的指针和缓冲区的大小作为参数，并将头指针和尾指针初始化为0。 在writeRingbuffer函数中，首先检查缓冲区是否已满。如果缓冲区已满，则不进行写操作，否则将数据写入缓冲区，并将头指针向前移动一个位置。 在readRingbuffer函数中，首先检查缓冲区是否为空。如果缓冲区为空，则不进行读操作，否则将数据从缓冲区读取出来，并将尾指针向前移动一个位置。 getRingbufferValidLen函数用于获取当前缓冲区中有效数据的长度，即头指针与尾指针之间的距离。 最后，在使用完环形缓冲区后，需要调用releaseRingbuffer函数来释放资源。 综上所述，环形缓冲区的C语言实现包括引用中的RingBuffer.h头文件和引用中的main.c源代码文件，其中实现了InitRingBuffer、writeRingbuffer、readRingbuffer、getRingbufferValidLen和releaseRingbuffer等函数。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Leon_George

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

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

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

打赏作者

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

抵扣说明：

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

余额充值