C环形buff

已于 2022-04-04 16:57:54 修改
阅读量655 收藏 5
点赞数 1
分类专栏： 游戏方面 文章标签： 算法 数据结构 架构 后端 游戏程序
于 2021-06-21 17:57:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45610260/article/details/118091794
版权

图解释

在这里插入图片描述

结构体

typedef struct byteQueue_s
{
	char*	pBuffer;//数据
	size_t	nCapacity;//容量
	size_t	nReadIndex;//读指针索引
	size_t	nWriteIndex;//写指针索引
} byteQueue_tt;

初始 结构体

假设要申请的空间 环形buff结构体大小为8

  • nWriteIndex 写指针索引
  • nReadIndex 读指针索引

环形buff初始化

void byteQueue_init(byteQueue_tt* pByteQueue,size_t nCapacity = /* = 8*/)
{
	pByteQueue->nReadIndex = nCapacity;//读指针索引位置设置为8,放到末尾
	pByteQueue->nWriteIndex = 0;//写指针索引位置设置成0，放到开头
	pByteQueue->nCapacity = nCapacity;//容量
	if( nCapacity != 0 )
	{
		pByteQueue->pBuffer = mem_malloc(nCapacity);//申请空间
	}
	else
	{
		pByteQueue->pBuffer = NULL;//置空
	}
}

image-20220307215459870

清空结构体

void byteQueue_clear(byteQueue_tt* pByteQueue)
{
	pByteQueue->nReadIndex = 0;//读指针索引位置设置为0,放到开头
	pByteQueue->nWriteIndex = 0;//写指针索引位置设置为0,放到开头
	pByteQueue->nCapacity = 0;//容量设置为0
	if(pByteQueue->pBuffer)
	{
		mem_free(pByteQueue->pBuffer);//如果有数据进行释放
		pByteQueue->pBuffer = NULL;//并且置空
	}
}

image-20220307215525672

获取剩余全部可写空间

static inline size_t byteQueue_getBytesWritable(byteQueue_tt* pByteQueue)
{
	if (pByteQueue->nReadIndex >= pByteQueue->nWriteIndex )//写指针和读指针重合，或者在读指针前面
	{
		return pByteQueue->nReadIndex - pByteQueue->nWriteIndex;//直接读指针 - 写指针 就是 写入了多少内容
	}
	else//写指针在读指针后面
	{
		return pByteQueue->nReadIndex + (pByteQueue->nCapacity - pByteQueue->nWriteIndex); //读指针位置 + (容量 - 写指针位置)
	}
}

写指针在读指针前面[求得是蓝色块数据]

image-20220401171227142

写指针在读指针后面[求得是蓝色块数据]

image-20220401170218636

获取剩余全部可读空间

static inline size_t byteQueue_getBytesReadable(byteQueue_tt* pByteQueue)
{
	if(pByteQueue->nWriteIndex > pByteQueue->nReadIndex) //读指针在写指针前面
	{
		return pByteQueue->nWriteIndex - pByteQueue->nReadIndex;//直接写指针 - 读指针 就是可以读多少数据
	}
	else //读指针和写指针重合,或者读指针在写指针后面
	{
		return pByteQueue->nWriteIndex + (pByteQueue->nCapacity - pByteQueue->nReadIndex); //写指针 + (容量 - 读指针位置)
	}
}

写指针在读指针后面[求的是红色块的数据]

image-20220401170253907

写指针在读指针前面[求的是红色块的数据]

查看连续的可写空间

//查看连续的可写空间
//size_t* pWriteBytes 能连续写入的大小
static inline char* byteQueue_peekContiguousBytesWrite(byteQueue_tt* pByteQueue, size_t* pWriteBytes)
{
	if (pByteQueue->nReadIndex >= pByteQueue->nWriteIndex)//读指针在写指针后面
	{
		*pWriteBytes = pByteQueue->nReadIndex - pByteQueue->nWriteIndex;//能连续写入的大小
	}
	else//读指针在写指针前面
	{
		*pWriteBytes = pByteQueue->nCapacity - pByteQueue->nWriteIndex;//能连续写入的大小
	}

	return pByteQueue->pBuffer + pByteQueue->nWriteIndex;//开始连续写入指针的起始位置
}

写指针在读指针前面[求得连续可写的空间]

image-20220401193238810

写指针在读指针后面[求得连续可写的空间]

image-20220401200102901

查看连续可读空间

//查看连续的可读空间
//size_t* pWriteBytes 能连续读取的大小
static inline char* byteQueue_peekContiguousBytesRead(byteQueue_tt* pByteQueue, size_t* pReadBytes)
{
	if(pByteQueue->nWriteIndex > pByteQueue->nReadIndex)//写指针在读指针后面
	{
		*pReadBytes = pByteQueue->nWriteIndex - pByteQueue->nReadIndex;//能连续读取的大小
	}
	else
	{
		*pReadBytes = pByteQueue->nCapacity - pByteQueue->nReadIndex;//能连续读取的大小
	}
	return pByteQueue->pBuffer + pByteQueue->nReadIndex;//开始连续读入指针的起始位置
}

写指针在读指针后面[求得连续可读的空间]

image-20220404154851362

写指针在读指针前面[求得连续可读的空间]

在这里插入图片描述

写入一个字符[空间不足按256的倍数自动扩展]

void byteQueue_writeChar(byteQueue_tt* pByteQueue, const char c)
{
	if(pByteQueue->nCapacity == 0)
	{
		//初始化容量,buffer大小，可读索引
		pByteQueue->nCapacity = 256;//初始化容量大小[256]
		pByteQueue->pBuffer = mem_malloc(pByteQueue->nCapacity);//申请空间
		pByteQueue->nReadIndex = pByteQueue->nCapacity;//初始化读索引位置
	}
	else
	{
		size_t nBytesWritable = byteQueue_getBytesWritable(pByteQueue);//获取获取剩余全部可写空间
		if (1 > nBytesWritable)
		{
			//align_size  将size按align大小整数倍提升,用于内存对齐
			size_t nNewCapacity = align_size( (pByteQueue->nCapacity << 1) + 1,256);

			char* pBuffer = mem_malloc(nNewCapacity);
			if(pByteQueue->nReadIndex != pByteQueue->nCapacity)//说明还有数据没有读走
			{
				size_t nWritten = byteQueue_getBytesReadable(pByteQueue);//获取剩余全部可读的空间
				size_t nReadBytes = 0;//连续可读的空间的大小
				char* pRead = byteQueue_peekContiguousBytesRead(pByteQueue, &nReadBytes);//开始读取数据的起始位置
				memcpy(pBuffer,pRead,nReadBytes);//直接拷贝
				if( nReadBytes != nWritten )//如果连续可读的空间的大小!=剩余全部可读的空间
				{
					memcpy(pBuffer+ nReadBytes,pByteQueue->pBuffer,nWritten - nReadBytes);//把剩下的可读的空间写入新buffer空间
				}
				pByteQueue->nReadIndex = 0;//到了新空间需要重新移动读指针
				pByteQueue->nWriteIndex = nWritten;//到了新空间需要重新移动写指针
			}
			else //没有数据需要读取直接初始化指针位置
			{
				pByteQueue->nReadIndex = nNewCapacity; 
				pByteQueue->nWriteIndex = 0;
			}

			pByteQueue->nCapacity = nNewCapacity;
			mem_free(pByteQueue->pBuffer);
			pByteQueue->pBuffer = pBuffer;
		}
	}

	pByteQueue->pBuffer[pByteQueue->nWriteIndex] = c;//赋值
	pByteQueue->nWriteIndex = (pByteQueue->nWriteIndex + 1) % pByteQueue->nCapacity;//索引位移一位
	if (pByteQueue->nReadIndex == pByteQueue->nCapacity)//如果读索引在尾部
	{
		pByteQueue->nReadIndex = 0;//把读索引放到头部
	}
}

写入指定大小空间的数据[空间不足按256的倍数自动扩展]

void byteQueue_write(byteQueue_tt* pByteQueue, const void* pInBytes, size_t nLength)
{
	assert(nLength != 0);
	if(pByteQueue->nCapacity == 0)//容量大小为0
	{
		pByteQueue->nCapacity = align_size(nLength,256);//初始化容量大小[256的倍数]
		pByteQueue->pBuffer = mem_malloc(pByteQueue->nCapacity);//申请空间
		pByteQueue->nReadIndex = pByteQueue->nCapacity;//初始化读索引位置
	}
	else
	{
		size_t nBytesWritable = byteQueue_getBytesWritable(pByteQueue);//获取剩余可写空间
		if (nLength > nBytesWritable)//如果写入的大小大于剩余可写空间
		{
			//数据进行扩展
			size_t nNewCapacity = align_size( (pByteQueue->nCapacity << 1) + (nLength-nBytesWritable),256);

			char* pBuffer = mem_malloc(nNewCapacity);//申请空间大小
			if(pByteQueue->nReadIndex != pByteQueue->nCapacity )//还有数据可读
			{
				size_t nWritten = byteQueue_getBytesReadable(pByteQueue);//剩余全部可读空间
				size_t nReadBytes = 0;//连续可读的空间大小
				char* pRead = byteQueue_peekContiguousBytesRead(pByteQueue, &nReadBytes);//开始连续读入指针的起始位置
				memcpy(pBuffer,pRead,nReadBytes);//把连续可读的空间写入新buffer空间
				if( nReadBytes != nWritten )//如果连续可读的空间!=剩余全部可读空间
				{
					memcpy(pBuffer + nReadBytes,pByteQueue->pBuffer,nWritten - nReadBytes);//把剩下的可读的空间写入新buffer空间
				}
				pByteQueue->nReadIndex = 0;//重置读索引
				pByteQueue->nWriteIndex = nWritten;//重置写索引
			}
			else
			{
				pByteQueue->nReadIndex = nNewCapacity;//重置读索引
				pByteQueue->nWriteIndex = 0;//重置写索引
			}
			pByteQueue->nCapacity = nNewCapacity;重置容量大小
			mem_free(pByteQueue->pBuffer);//释放旧buff空间
			pByteQueue->pBuffer = pBuffer;//重置指针到新buff空间
		}
	}

	size_t nWriteBytes = 0;//连续可写的空间大小
	char* pWrite = byteQueue_peekContiguousBytesWrite(pByteQueue,&nWriteBytes);//开始写入的指针位置
	
	if (nWriteBytes >= nLength)//如果连续写入的空间能够满足需要写入的空间大小
	{
		memcpy(pWrite, pInBytes, nLength);//直接拷贝
	}
	else
	{
		memcpy(pWrite, pInBytes, nWriteBytes);//先拷贝连续可写入的空间大小
		memcpy(pByteQueue->pBuffer, (const char*)pInBytes + nWriteBytes, nLength - nWriteBytes);//再把剩余要写入的大小空间写入
	}
	pByteQueue->nWriteIndex = (pByteQueue->nWriteIndex + nLength) % pByteQueue->nCapacity;//重置读索引
	if (pByteQueue->nReadIndex == pByteQueue->nCapacity)
	{
		pByteQueue->nReadIndex = 0;//重置写索引
	}
}

写入指定大小空间的数据[空间不足按剩余需要空间大小申请]

void byteQueue_writeBytes(byteQueue_tt* pByteQueue, const void* pInBytes, size_t nLength)
{
	assert(nLength != 0);
	if(pByteQueue->nCapacity == 0)//容量大小为0
	{
		pByteQueue->nCapacity = nLength;//初始化容量大小[需要空间大小]
		pByteQueue->pBuffer = mem_malloc(pByteQueue->nCapacity);//申请空间
		pByteQueue->nReadIndex = pByteQueue->nCapacity;//初始化读索引位置
	}
	else
	{
		size_t nBytesWritable = byteQueue_getBytesWritable(pByteQueue);//剩余可写的全部空间大小
		if (nLength > nBytesWritable)//如果写入的大小大于剩余可写入的空间大小
		{
			size_t nNewCapacity = pByteQueue->nCapacity + (nLength - nBytesWritable);//开辟正好大小的空间
			char* pBuffer = mem_malloc(nNewCapacity);//申请空间
			if(pByteQueue->nReadIndex != pByteQueue->nCapacity)//还有空间可读需要把这段空间赋值到新空间
			{
				size_t nWritten = byteQueue_getBytesReadable(pByteQueue);//剩余可读的全部空间
				size_t nReadBytes = 0;//连续可读的空间
				char* pRead = byteQueue_peekContiguousBytesRead(pByteQueue, &nReadBytes);//开始读取空间的起始位置
				memcpy(pBuffer,pRead,nReadBytes);//拷贝到新空间
				if( nReadBytes != nWritten )//连续可读的空间!=剩余可读的全部空间
				{
					memcpy(pBuffer+ nReadBytes,pByteQueue->pBuffer,nWritten - nReadBytes);//拷贝剩余数据到新空间
				}
				pByteQueue->nReadIndex = 0;//重置读索引
				pByteQueue->nWriteIndex = nWritten;//重置写索引
			}
			else
			{
				pByteQueue->nReadIndex = nNewCapacity;//重置读索引
				pByteQueue->nWriteIndex = 0;//重置写索引
			}
			pByteQueue->nCapacity = nNewCapacity;//重置容量
			mem_free(pByteQueue->pBuffer);//释放旧空间
			pByteQueue->pBuffer = pBuffer;//新空间指针指向旧空间指针
		}
	}

	size_t nWriteBytes = 0;//连续可写入空间大小
	char* pWrite = byteQueue_peekContiguousBytesWrite(pByteQueue,&nWriteBytes);//可写入开始指针
	if (nWriteBytes >= nLength)//容量足够
	{
		memcpy(pWrite, pInBytes, nLength);//直接拷贝
	}
	else
	{
		memcpy(pWrite, pInBytes, nWriteBytes);//先拷贝连续可写入空间大小
		memcpy(pByteQueue->pBuffer, (const char*)pInBytes + nWriteBytes, nLength - nWriteBytes);//剩余的在直接拷贝
	}
	pByteQueue->nWriteIndex = (pByteQueue->nWriteIndex + nLength) % pByteQueue->nCapacity;//重置写索引
	if (pByteQueue->nReadIndex == pByteQueue->nCapacity)
	{
		pByteQueue->nReadIndex = 0;//重置读索引
	}
}

读取数据

bool byteQueue_readBytes(byteQueue_tt* pByteQueue, void* pOutBytes, size_t nMaxLengthToRead, bool bPeek /*= false*/ )
{
	size_t nBytesWritten = byteQueue_getBytesReadable(pByteQueue);//可读的空间大小
	size_t nBytesToRead = nBytesWritten < nMaxLengthToRead ? nBytesWritten : nMaxLengthToRead;//得到可读取的大小
	if (nBytesToRead == 0)
	{
		return false;
	}

	size_t nReadBytes = 0;//连续可读的大小
	char* pRead = byteQueue_peekContiguousBytesRead(pByteQueue, &nReadBytes);//连续可读空间大小的起始索引
	if( nReadBytes >= nBytesToRead )//满足可读大小需求
	{
		memcpy(pOutBytes,pRead,nBytesToRead);//直接读取
	}
	else
	{
		memcpy(pOutBytes,pRead,nReadBytes);//直接连续可读的空间大小
		memcpy((char*)pOutBytes+nReadBytes,pByteQueue->pBuffer,nBytesToRead-nReadBytes);//读取剩余需要读取的大小
	}
	
	if (!bPeek)//不是探测
		byteQueue_readOffset(pByteQueue,nBytesToRead);//直接移动指针

	return true;
}

重置容量

void byteQueue_reserve(byteQueue_tt* pByteQueue, size_t nCapacity)
{
	size_t nWritten = byteQueue_getBytesReadable(pByteQueue);//剩余全部可读大小
	if(nWritten > nCapacity)//如果全部可读的大小大于要重置的容量大小
	{
		return;
	}

	if(pByteQueue->nReadIndex != pByteQueue->nCapacity)//有剩余需要读取的空间数据
	{
		char* pBuffer = mem_malloc(nCapacity);//申请新的重置空间大小
		size_t nReadBytes = 0;//连续可读的空间大小
		char* pRead = byteQueue_peekContiguousBytesRead(pByteQueue, &nReadBytes);//连续可读空间大小的起始位置
		memcpy(pBuffer,pRead,nReadBytes);//直接拷贝
		if( nReadBytes != nWritten )//还有剩余要拷贝的空间
		{
			memcpy(pBuffer + nReadBytes,pByteQueue->pBuffer,nWritten - nReadBytes);//拷贝剩余要拷贝的数据
		}
		pByteQueue->nReadIndex = 0;//重置读索引
		pByteQueue->nWriteIndex = nWritten;//重置写索引
		mem_free(pByteQueue->pBuffer);//释放旧空间
		pByteQueue->pBuffer = pBuffer;//新空间的指针指向旧空间指针
	}
	else
	{
		pByteQueue->pBuffer = mem_realloc(pByteQueue->pBuffer,nCapacity);//直接指向申请空间的大小
		pByteQueue->nReadIndex = nCapacity;//重置读索引
		pByteQueue->nWriteIndex = 0;//重置写索引
	}
	pByteQueue->nCapacity = nCapacity;//重置容量
}
青蛙~~
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
串口环形BUFF.pdf
07-17
使用超级方便，仅3个函数。初始化、读、写。 写函数放在中断中即可。 读函数放在主循环中，直接轮询就可以了。当一帧数据结束时，读函数将输出帧长度。 初始化函数用来初始化存储空间。
C语言环形队列通用模块
12-30
环形队列在C语言中的实现通常涉及到动态内存分配、指针操作以及对数据结构的理解。 在本“C语言环形队列通用模块”中，它以一种灵活的方式设计，能够适应各种数据类型，而不仅仅是特定类型的元素。这通常是通过使用...
STM32/GD32学习指南-踩坑之（三）环形buffer使用方法，环形缓存区的读取操作方法
qq_38584212的博客
07-14 1177
例如：现在有一个串口，接收到外部发来的数据，将其存入到环形buffer中，然后再从该环形buffer中将数据读取出来，进行一些帧格式、数据校验的操作，再从该串口发送出去。在处理接收数据时，经常使用到环形buffer存储数据进行处理，尤其是单片机中，内存本来就小，就需要节约内存的使用。Head：当前队列头部，也就是下次数据读取时的首地址，根据数据的存取状态，是动态变化的。Tail：当前队列尾，也就是下次数据写入时的首地址，根据数据的存取状态，是动态变化的。3. 读取环形buffer中的数据。
[缓存] RingBuff 环形队列、环形缓冲区及有锁无锁实现
小田的专栏
02-20 1404
由于自旋锁不需要进行线程切换，所以它完全在用户态下实现，加锁开销低，但是由于其采用忙等待的策略，对于短期加锁来说没问题，但是长期锁定的时候就会导致CPU资源的大量消耗。如果读取数据的速度跟不上写入数据的速度，旧的数据将被新写入的数据覆盖。所以当互斥锁加锁失败的时候，就伴随着两次上下文切换的开销，而如果我们锁定的时间较短，可能上下文切换的时间会比锁定的时间还要长。由于自旋锁和互斥锁的失败策略不同，自旋锁采用忙等待的策略，而互斥锁采用线程切换的策略，由于策略不同，它们的应用场景也不同。
C语言知识点 - 001：环形缓冲区Ring Buffer详细分析记录
梦想技术家
05-08 538
称作，也称作环形队列（circular queue），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。如下为的概念示意图。在任务间的通信、串口数据收发、log缓存、网卡处理网络数据包、音频/视频流处理中均有的应用。在的和文件中，内核文件kfifo.h和kfifo.c中也有的代码实现。由于计算机内存是线性地址空间，因此需要特别的算法设计才可以从逻辑上实现。先不要想的具体实现细节，来看一个简单的例子。如下是一个空间大小为。
RingBuffer 环形缓冲区----镜像指示位
呵呵哒!的博客
08-19 904
称作环形缓冲区，也称作环形队列（circular queue），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。这个宏定义用于计算向下对齐的地址。size和align。size是要对齐的内存大小，align是所需的对齐大小。这个宏返回一个值，该值是size向下对齐到align边界后的地址。例如，假设我们有一个 32 位的系统，并且我们需要将数据对齐到 64 位的边界。我们可以使用在这个例子中，data数组的大小为 10 个元素，我们需要将其对齐到 8 字节边界。宏返回data。
环形缓冲区RingBuff的代码实现
qq_37491844的博客
12-06 896
~今天我们一起来聊一下环形缓冲区RingBuff又叫LoopBuff等等，都是相同的东西，只是一个名字不同罢了。 ~我们在编写代码的时候缓冲区是几乎每个代码都必不可少的东西，比如存放串口接收的数据、做Modbus通讯、和一些模块通讯等等都会用到缓冲区，简单的来写的话往往就是开辟一个buffer，把接收到的数据保存在这个buffer中，然后再去解析这个buffer的数据。 以串口和GPS通讯为例，我们常常使用串口接收中断接收GPS的数据包，把接收到的数据保存在RecBuff中，然后再去申明一个函数去解析这个数
C语言数组
qq_63250428的博客
07-05 595
数组概述
C语言环形队列
03-27
C语言写的环形队列，实现队列的入队 出队
C语言环形缓冲区
03-10
环形缓冲区是一种高效的数据通信和数据存储结构，在C语言编程中经常被用来解决多线程环境中的数据共享问题。它的设计灵感来源于计算机内存管理中的“缓冲”概念，通过一个固定大小的数组来实现，数据在缓冲区中循环...
基于C语言的环形数组的实现.zip
最新发布
05-13
在C语言中，实现环形数组可以帮助我们高效地处理数据，尤其是在需要进行循环队列、缓冲区或者固定大小的历史记录等功能时。下面我们将深入探讨环形数组的概念、优点、以及如何在C语言中实现。 1. **环形数组概念** ...
03_环形buff
Chockong的博客
06-09 177
把接收到的数据先填到环形buff里面。 #define bleRINGBUFF_LEN 128 typedef struct { uint8 Head; uint8 Tail; uint8 Lenght; uint8 bleRing_Buff[bleRINGBUFF_LEN]; }bleRingBuff_t;//环形buff结构体 //======================================= //写ble环形buff uint8 ble
C++ 环形缓冲区RingBuffer 简单实现
热门推荐
搬砖小能手
02-18 1万+
C++环形缓冲区RingBuffer的简单实现
环形缓冲区.ringbuff(C#和java)
weixin_30443747的博客
05-10 294
环形缓冲， 本质就是队列fifo，先进先出的特殊版本，环形队列，是用空间得到了顺序存储的快索引的优点，又避免了删除，移动数据的缺点。并且还享受了单生产/单消费，2线程的无锁线程优势。十分完美。 1.面对频率超级频繁的读写，环形缓冲修改为固定大小的队列，不添加操作，并且使用后，也不删除和移动。坏处是，必须预设内存空间。所以适合超级频繁的读写，反正基本是一直占用。 2.因为要实现环形，所以一般有...
ring buffer 环形队列 C++实现
隔壁老王呀的专栏
08-24 1397
#include <iostream> using namespace std; template <class T> class RingBuff { private: unsigned int m_size; int m_in; int m_out; T *m_data; public: R...
C语言数据结构（环形缓冲区）
weixin_39270987的博客
09-11 2251
一、什么是环形缓冲区 环形缓冲区本质上也是环形队列，和环形对列不同的是，环形缓冲区允许用户一次性写入和读取多个队列元素； 二、对环形缓冲区的简单理解 我们可以把环形缓冲区想象成一个蓄水池，它有一个入水口和出水口，如果入水的速度大于出水的速度，在一段时间后蓄水池就会存满水，这时即使关闭入水口，出水口还是会源源不断的有水流出。 图片来源于百度图片 二、环形缓冲区的应用 环形缓冲区通常应用于具有生产者和消费者的场景，比如我们需要实现一首音乐的在线播放，假设一首音乐的大小为5M，在带宽充足的情况下下载完
c语言字节缓存,C语言实现的一个缓存队列
weixin_30628943的博客
05-18 346
/*** @file queue.c* @brief Create by AnKun on 2019/10/30* @version 1.0.0*/#include "queue.h"/*** 获得队列使用量* @param queue 队列句柄* @return 返回已使用量*/uint32_t Queue_GetUsed(const QueuePtr queue){in...
环形buffer C语言简单实现
u011123091的博客
08-26 4321
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; typedef struct circlebuffer { int size;//用于判断环形buffer是否是满的 int wroffset; int rdoffser; char * buf; int buflen; }circl...
c语言图文详解 实现ringbuff 源码详解
杀手的博客
08-28 3648
一 什么是ringbuff ringbuff是环形buff，是buff缓存的一种，可以用来存放程序运行过程的暂时数据。一般的buff即是一个数组，而环形buff就是将数组的头和尾链接起来的数组。 老规矩，源码先放这：https://gitee.com/killerp/ringbuff.git 1，ringbuff的优点 ringbuff比普通的buff使用更加高效灵活，可以边读数据边写数据。 二 ringbuff的实现 一个ringbuff的实现至少需要以下四个功能： 创建ringbuff 数据写入rin
c语言环形加密解密算法
06-10
下面是一个使用C语言实现环形加密解密算法的示例代码： ```c #include #include void encrypt(char *str, int key) { int len = strlen(str); for (int i = 0; i ; i++) { str[i] = (str[i] + key) % 128; }...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值