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 语言中实现环形缓冲区
09-02
本文主要是介绍 C语言实现环形缓冲区,并附有详细实现代码,具有一定的参考价值,希望能帮助有需要的小伙伴
C语言--环形缓存区
有人住高楼，有人在深沟；有人光万丈，有人一身锈。
08-03 4224
环形缓冲区最重要的一个特点是写的速度和读的速度匹配性问题，环形缓冲区一般是将数据先写入缓冲区内，然后有个写的指针位置，但是不能超过读的位置，因为数据还未被读取，便写入数据，就会造成数据还未被读取便被新的数据覆盖，造成数据的丢失。读数据同样原理，读的指针不能超过写的位置，这样就会读到之前读过的数据，造成数据的重复。空间如果设置的太大，会造成内存的浪费，有内存一直处于空闲状态，如果空间设置到的太小，可能会造成读的速度快于写的速度，导致读的过程中会有短暂的等待时间，造成效率不是最高。2、写入数据>缓冲区。....
对免杀木马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语言）
little_rookie__的博客
11-24 3558
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入
C语言实现环形缓冲区
m0_49476241的博客
09-01 3754
本篇文章将为大家介绍一下什么是环形缓冲区，在很多场合都可以使用环形缓冲区，他既可以进行数据的写入也可以进行数据的读取，使用环形缓冲区可以减小数据丢失的风险，更加保证了数据的安全性和有效性。在通信程序中，经常使用环形缓冲器作为数据结构来存放通信中发送和接收的数据。环形缓冲区是一个先进先出的循环缓冲区，可以向通信程序提供对缓冲区的互斥访问。环形缓冲区在嵌入式开发中会经常使用到，我希望大家能够将这个知识点牢记于心。...
环形缓冲区（c语言）
qq_45570844的博客
02-28 899
C语言环形缓冲区
C语言环形缓冲区
m0_48995611的博客
06-21 747
本文提供一种C语言环形缓冲区的实现方法。
无锁 环形缓冲区
08-15
`ReadMe.txt`文件通常是项目说明或指南，可能包含了如何使用这个无锁环形缓冲区库的详细信息，包括如何构建、如何在代码中引入和使用，以及可能存在的限制和注意事项。 在实际应用中，无锁环形缓冲区可以用于各种...
环形缓冲区_环形buffer_
10-03
这个源代码可能包含了结构体定义、初始化函数、读写操作函数、状态检查函数以及可能的同步控制机制，这些都是构建和使用环形缓冲区的关键组成部分。通过对源代码的分析和实践，你能够更好地掌握如何在自己的项目中...
22. USART_CircleBuffer 串口接收环形缓冲区
04-05
通过上述步骤，结合STM32的USART中断功能和环形缓冲区技术，我们可以构建一个高效、可靠的串口接收系统。这种方案不仅可以减少CPU的实时性负担，还能提高系统的响应速度，适用于各种需要实时处理串口数据的场景。 ...
基于C语言多个共享内存构成环形缓冲(操作系统实验)【100012384】
05-24
在本实验中，我们将深入探讨基于C语言的多进程通信技术，特别关注如何利用共享内存构建环形缓冲区。在操作系统领域，这种技术是进程间通信（IPC, Inter-Process Communication）的一种有效手段，用于协调不同进程...
lwrb：轻型通用环形缓冲区管理器库
01-30
lwrb是一个专门针对C语言设计的轻量级、通用的环形缓冲区管理器库，它提供了一套简洁且高效的API，方便开发者在各种应用场景下构建和管理环形缓冲区。 lwrb库的核心特性包括： 1. **线程安全**： lwrb库考虑到了...
C实现循环缓冲区，线程交替执行，进行数据读取
05-09
在C语言中实现循环缓冲区，首先需要定义一个固定大小的缓冲区，通常使用结构体来封装缓冲区的指针、读写位置索引以及缓冲区大小等信息。例如： ```c typedef struct { char* buffer; // 缓冲区指针 size_t size; ...
基于 C 实现的环形数组（环形数组的实现）
05-13
在C语言中实现环形数组，通常用于构建数据缓冲区，尤其是在处理实时数据流或者需要高效插入和删除操作的场景下，如音频处理、网络数据包接收等。以下是对环形数组的详细介绍及其C语言实现的关键点。 ### 环形数组的...
数据结构（C语言版）(第2版) —— 严蔚敏 李冬梅 吴伟民.zip
06-14
队列则是先进先出（FIFO）的数据结构，常见于任务调度和缓冲区管理。 4. **树**：树结构模拟了自然界中的分层关系，如文件系统的目录结构。二叉树、平衡树（如AVL树、红黑树）和搜索树（如BST）是重要的树形数据...
FIFO环形队列.rar
10-14
在STM32中，硬件层面通常提供了FIFO缓冲区，用于串口数据的收发。硬件FIFO能减轻CPU负担，提高系统效率，因为它能在中断服务例程中自动处理数据的接收和发送，而无需CPU持续监控。 在串口通信中，环形队列软件实现...
【C语言】环形缓冲区
m0_61011506的博客
10-04 1186
文章目录一、环形缓冲区的特性二、算法说明三、代码示例 一、环形缓冲区的特性 1、先进新出 2、当缓冲区被使用完，且又有新的数据需要存储时，丢掉历史最久的数据，保存最新数据。 现实中的存储介质都是线性的，因此我们需要做一下处理，才能在功能上实现环形缓冲区。 这里写图片描述： 二、算法说明 1、pHead和pTail分别是连续存储介质的首地址和尾地址 2、pTail - pHead 的值是环形缓冲区的总长度 3、pValid 是使用区域的起始指针，取数据时的起点，当取数据时pValid要发生偏移 4、pVa
C语言知识点 - 001：环形缓冲区Ring Buffer详细分析记录
梦想技术家
05-08 1372
称作，也称作环形队列（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、付费专栏及课程。

余额充值