C++版循环缓冲

最新推荐文章于 2022-08-01 17:27:24 发布
最新推荐文章于 2022-08-01 17:27:24 发布
阅读量540 收藏
点赞数
分类专栏： 通信传输 文章标签： 循环缓冲
原文链接：http://blog.163.com/qimo601@126/blog/static/1582209320121169244219/
版权

CCycleBuffer.h

#ifndef __test__CCycleBuffer__
#define __test__CCycleBuffer__
 
#include <iostream>
#include <assert.h>
class CCycleBuffer
{
public:
    bool isFull();
    bool isEmpty();
    void Empty();
    int GetLength();
    CCycleBuffer(int size);
    virtual ~CCycleBuffer();
    int Write(char* buf, int count);
    int Read(char* buf, int count);
private:
    bool m_bEmpty, m_bFull;
    char * m_pBuf;
    int m_nBufSize;
    int m_nReadPos;
    int m_nWritePos;
    
public:
    int GetReadPos() { return m_nReadPos; }
    int GetWritePos() { return m_nWritePos; }
};
#endif /* defined(__test__CCycleBuffer__) */

CCycleBuffer.c

//环形缓冲区源文件
//尽量用C运行时库代码，改变了原作者基于WindowsAPI的代码。
//修改了原作者的两处错误，1是read函数最后的else 少了一个leftcount
//第二个错误，是write函数中，m_nWritePos 变量，他重新定义了一个。这些错误编译不会出错。
//但是运行起来，要了亲命啊。
 
#include "CCycleBuffer.h"
#include <assert.h>
#include <memory.h>
// 定义 
CCycleBuffer::CCycleBuffer(int size)
 
{<br>m_nBufSize = size; 
m_nReadPos =0; 
m_nWritePos =0; 
m_pBuf =newchar[m_nBufSize];
m_bEmpty =true; 
m_bFull =false;
test =0;
} 
CCycleBuffer::~CCycleBuffer() 
{ 
delete[] m_pBuf; 
} 
/************************************************************************/ 
/* 向缓冲区写入数据，返回实际写入的字节数                               */ 
/************************************************************************/ 
int CCycleBuffer::write(char* buf,int count) 
{ 
if(count <=0)
  return0; 
m_bEmpty =false; 
// 缓冲区已满，不能继续写入 
if(m_bFull)  
{ 
  return0; 
} 
else if(m_nReadPos == m_nWritePos)// 缓冲区为空时 
{ 
  /*                          == 内存模型 ==
     (empty)             m_nReadPos                (empty)                      
  |----------------------------------|-----------------------------------------|
         m_nWritePos        m_nBufSize
  */ 
  int leftcount = m_nBufSize - m_nWritePos; 
  if(leftcount > count) 
  { 
   memcpy(m_pBuf + m_nWritePos, buf, count); 
   m_nWritePos += count; 
   m_bFull =(m_nWritePos == m_nReadPos); 
   return count; 
  } 
  else 
  { 
   memcpy(m_pBuf + m_nWritePos, buf, leftcount); 
   m_nWritePos =(m_nReadPos > count - leftcount)? count - leftcount : m_nWritePos; 
   memcpy(m_pBuf, buf + leftcount, m_nWritePos); 
   m_bFull =(m_nWritePos == m_nReadPos); 
   return leftcount + m_nWritePos; 
  } 
}  
else if(m_nReadPos < m_nWritePos)// 有剩余空间可写入 
{ 
  /*                           == 内存模型 ==
   (empty)                 (data)                     (empty)
  |-------------------|----------------------------|---------------------------|
     m_nReadPos                m_nWritePos       (leftcount)           
  */ 
  // 剩余缓冲区大小(从写入位置到缓冲区尾) 
 
  int leftcount = m_nBufSize - m_nWritePos;
  int test = m_nWritePos;
  if(leftcount > count)   // 有足够的剩余空间存放 
  { 
   memcpy(m_pBuf + m_nWritePos, buf, count); 
   m_nWritePos += count; 
   m_bFull =(m_nReadPos == m_nWritePos); 
   assert(m_nReadPos <= m_nBufSize); 
   assert(m_nWritePos <= m_nBufSize);     
   return count; 
  } 
  else       // 剩余空间不足 
  { 
   // 先填充满剩余空间，再回头找空间存放 
   memcpy(m_pBuf + test, buf, leftcount); 
 
   m_nWritePos =(m_nReadPos >= count - leftcount)? count - leftcount : m_nReadPos; 
   memcpy(m_pBuf, buf + leftcount, m_nWritePos); 
   m_bFull =(m_nReadPos == m_nWritePos);    
   assert(m_nReadPos <= m_nBufSize); 
   assert(m_nWritePos <= m_nBufSize);  
   return leftcount + m_nWritePos; 
  } 
} 
else 
{ 
  /*                          == 内存模型 ==
   (unread)                 (read)                     (unread)
  |-------------------|----------------------------|---------------------------|
      m_nWritePos    (leftcount)    m_nReadPos                      
  */ 
  int leftcount = m_nReadPos - m_nWritePos; 
  if(leftcount > count) 
  { 
   // 有足够的剩余空间存放 
   memcpy(m_pBuf + m_nWritePos, buf, count); 
   m_nWritePos += count; 
   m_bFull =(m_nReadPos == m_nWritePos); 
   assert(m_nReadPos <= m_nBufSize); 
   assert(m_nWritePos <= m_nBufSize);  
   return count; 
  } 
  else 
  { 
   // 剩余空间不足时要丢弃后面的数据 
   memcpy(m_pBuf + m_nWritePos, buf, leftcount); 
   m_nWritePos += leftcount; 
   m_bFull =(m_nReadPos == m_nWritePos); 
   assert(m_bFull); 
   assert(m_nReadPos <= m_nBufSize); 
   assert(m_nWritePos <= m_nBufSize);    
   return leftcount; 
  } 
} 
} 
/************************************************************************/ 
/* 从缓冲区读数据，返回实际读取的字节数                                 */ 
/************************************************************************/ 
int CCycleBuffer::read(char* buf,int count) 
{ 
if(count <=0)
  return0; 
m_bFull =false; 
if(m_bEmpty)       // 缓冲区空，不能继续读取数据 
{ 
  return0; 
} 
else if(m_nReadPos == m_nWritePos)   // 缓冲区满时 
{ 
  /*                          == 内存模型 ==
   (data)          m_nReadPos                (data)    
|--------------------------------|--------------------------------------------|
    m_nWritePos         m_nBufSize
  */ 
  int leftcount = m_nBufSize - m_nReadPos; 
  if(leftcount > count) 
  { 
   memcpy(buf, m_pBuf + m_nReadPos, count); 
   m_nReadPos += count; 
   m_bEmpty =(m_nReadPos == m_nWritePos); 
   return count; 
  } 
  else 
  { 
   memcpy(buf, m_pBuf + m_nReadPos, leftcount); 
   m_nReadPos =(m_nWritePos > count - leftcount)? count - leftcount : m_nWritePos; 
   memcpy(buf + leftcount, m_pBuf, m_nReadPos); 
   m_bEmpty =(m_nReadPos == m_nWritePos); 
   return leftcount + m_nReadPos; 
  } 
} 
else if(m_nReadPos < m_nWritePos)   // 写指针在前(未读数据是连接的) 
{ 
  /*                          == 内存模型 ==
   (read)                 (unread)                      (read)    
  |-------------------|----------------------------|---------------------------|
     m_nReadPos                m_nWritePos                     m_nBufSize
  */ 
  int leftcount = m_nWritePos - m_nReadPos; 
  int c =(leftcount > count)? count : leftcount; 
  memcpy(buf, m_pBuf + m_nReadPos, c); 
  m_nReadPos += c; 
  m_bEmpty =(m_nReadPos == m_nWritePos); 
  assert(m_nReadPos <= m_nBufSize); 
  assert(m_nWritePos <= m_nBufSize); 
  return c; 
} 
else          // 读指针在前(未读数据可能是不连接的) 
{ 
  /*                          == 内存模型 ==
     (unread)                (read)                      (unread)
  |-------------------|----------------------------|---------------------------|
      m_nWritePos                  m_nReadPos                  m_nBufSize
 
  */ 
  int leftcount = m_nBufSize - m_nReadPos; 
  if(leftcount > count)   // 未读缓冲区够大，直接读取数据 
  { 
   memcpy(buf, m_pBuf + m_nReadPos, count); 
   m_nReadPos += count; 
   m_bEmpty =(m_nReadPos == m_nWritePos); 
   assert(m_nReadPos <= m_nBufSize); 
   assert(m_nWritePos <= m_nBufSize); 
   return count; 
  } 
  else       // 未读缓冲区不足，需回到缓冲区头开始读 
  { 
   memcpy(buf, m_pBuf + m_nReadPos, leftcount); 
   m_nReadPos =(m_nWritePos >= count - leftcount)? count - leftcount : m_nWritePos; 
   memcpy(buf + leftcount, m_pBuf, m_nReadPos); 
   m_bEmpty =(m_nReadPos == m_nWritePos); 
   assert(m_nReadPos <= m_nBufSize); 
   assert(m_nWritePos <= m_nBufSize); 
   return leftcount + m_nReadPos; 
  }   
} 
} 
/************************************************************************/ 
/* 获取缓冲区有效数据长度                                               */ 
/************************************************************************/ 
int CCycleBuffer::getLength() 
{ 
if(m_bEmpty) 
{ 
  return0; 
} 
else if(m_bFull) 
{ 
  return m_nBufSize; 
} 
else if(m_nReadPos < m_nWritePos) 
{ 
  return m_nWritePos - m_nReadPos; 
} 
else 
{ 
  return m_nBufSize - m_nReadPos + m_nWritePos; 
} 
} 
void CCycleBuffer::empty() 
{ 
m_nReadPos =0; 
m_nWritePos =0; 
m_bEmpty =true; 
m_bFull =false; 
} 
bool CCycleBuffer::isEmpty() 
{ 
return m_bEmpty; 
} 
bool CCycleBuffer::isFull() 
{ 
return m_bFull; 
}

测试

#include "CCycleBuffer.h"

int main()
{
	CCycleBuffer buffer(100);
	char* datachar = new char[40];
	char* reschar = new char[100];

	int res = 0;

	for (int i = 0; i < 40; ++i)
	{
		datachar[i] = i + 1;
	}
	res = buffer.Write(datachar, 40);
	printf("写入数据个数：%d\n", res);
	res = buffer.Write(datachar, 40);
	printf("写入数据个数：%d\n", res);
	res = buffer.Write(datachar, 40);
	printf("写入数据个数：%d\n", res);
	res = buffer.Write(datachar, 40);
	printf("写入数据个数：%d\n", res);

	res = buffer.Read(reschar, 100);
	printf("读取数据个数：%d\n", res);
	for (int i = 0; i < 100; ++i)
	{
		if (i % 10 == 0)
		{
			printf("\n");
		}
		printf("%2d   ", reschar[i]);
	}

	return 0;
}

 

bo_2018
关注
专栏目录
通用循环缓冲区类(c++版)
xujunjie的专栏
04-09 1469
// 声明class CCycleBuffer  {public: BOOL isFull(); BOOL isEmpty(); void Empty(); int GetLength(); CCycleBuffer(int size); virtual ~CCycleBuffer(); int Write(char* buf, int count); int Read(char* buf,
C++封装 循环缓冲区
11-23
C++ 封装的循环缓冲区类，可扩展，用于视频接收缓存区、消息接收缓冲区、解析数据缓冲区
C++版循环缓冲区类
Care iOS技术团队
01-26 5579
// 声明 class CCycleBuffer { public: BOOL isFull(); BOOL isEmpty(); void Empty(); int GetLength(); CCycleBuffer(int size); virtual ~CCycleBuffer(); int Write(char* buf, int count); int Read(ch
循环缓冲区C++
04-30
循环缓冲区，采用C++开发。 实现了数据的读写操作。
无锁循环缓冲区的实现c语言,C++ 无锁环形缓冲区实现
weixin_35403151的博客
05-20 570
前段时间有个项目要实现一个基于live555的rtspserver，部分功能要用到环形缓冲区，网上看了一些blog，大部分是实验性质的，不太敢用，原理比较简单，所以就自己写了一个；实现环形缓冲区的关键点：1. 一个线程读，一个线程写2. 读线程维护读指针，写线程维护写指针3.数据一致性3.1 写线程写数据时，要先确定读指针；读线程读数据时，要先确定写指针；这里写的可能比较拗口，其实就是 写线程写...
循环缓冲区c++
random_liu_2013
08-30 323
template<typename T,int N> class RingBuf { public: RingBuf() : capSize(N){ first = last = 0; size = 0; } ~RingBuf() { } bool get(T& a) { if (is...
linux c++循环缓冲区模板类
07-26 213
一：概述 实际学习和工作中，我们经常会遇到读写大量数据的情况，这个时候我们可能就用到了循环缓冲区。 循环缓冲区在处理大量数据的时候有很大的优点，循环缓冲区在一些竞争问题上提供了一种免锁的机制，免锁的前提是，生产者和消费都只有一个的情况下，否则也要加锁。 二：循环缓冲区的实现理论如下图 三：实现代码如下所示： //CRecycleQueue.h #include&l...
【C++】31. Boost::circular_buffer——循环缓冲区
u011754972的博客
05-31 980
一、概述 Boost.Circular_buffer维护了一块连续内存块作为缓存区，当缓存区内的数据存满时，继续存入数据就覆盖掉旧的数据。 它是一个与STL兼容的容器，类似于 std::list或std::deque,并且支持随机存取。circular_buffer 被特别设计为...
c++ 实现循环缓存buffer
The Coding World
12-05 2039
循环buffer是一种高效缓存方式，一般用于接收固定长度协议使用。如果使用不断扩展的缓存操作(见：https://blog.csdn.net/chinabhlt/article/details/102751880)，则我们必须要malloc不断扩张缓存，还会memcpy或memmve操作，效率比较低，而ringbuffer则很好的规避这些低效操作。如果协议长度是固定的，则可以使用ringbuffe...
c和c++的循环buffer
weixin_42403965的博客
06-01 628
这是循环buffer的源码，可用于中断。 c文件 #include "buffer.h" #if C_CODE //c code void DataBufferInit(DataBuffer *intance) { if(NULL == intance){ return; } intance->last_recv_time = 0; intance->first = 0; intance->last = 0; inta
【C++模块实现】| 【08】循环覆盖写内存缓冲区（日志中多线程记录）
weixin_45926547的博客
08-01 963
循环缓冲区(也称为环形缓冲区)是固定大小的缓冲区，工作原理就像内存是连续的且可循环的一样；-在生成和使用内存时，不需将原来的数据全部重新清理掉，只要调整head/tail指针即可；-当添加数据时，head指针前进。当使用数据时，tail指针向前移动；-当到达缓冲区的尾部时，指针又回到缓冲区的起始位置；...
C++版的循环缓冲区类（实际测试可用！）
RationalGo的专栏
07-27 1020
[cpp] view plaincopy /*   * CCycleBuffer.h   *   *  Created on: 2013-5-27   *      Author: shiguang   */      #ifndef __test__CCycleBuffer__   #define __test__CCycleBuffer__  
循环缓冲区C++的一种实现
青春不谢的专栏
09-09 3252
之前去腾讯面试的时候被问到的一道题目：实现一个循环缓冲区（不带互斥锁）。仔细一想，其实和循环队列的思想一模一样，还是怪自己数据结构没学好阿（其实我是学通信的，所以最近在恶补）。还是先上代码 头文件如下，CircleBuffer.h #ifndef _CIRCLE_BUFFER_H_ #define _CIRCLE_BUFFER_H_ //basic data type rename ty
linux 下面实现c++实现循环缓冲区（1）
qq_39971579的博客
01-23 539
1.循环缓冲区的原理 环形缓冲区通常有一个读指针和一个写指针。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区中可写的缓冲区。通过移动读指针和写指针就可以实现缓冲区的数据读取和写入。在通常情况下，环形缓冲区的读用户仅仅会影响读指针，而写用户仅仅会影响写指针。如果仅仅有一个读用户和一个写用户，那么不需要添加互斥保护机制就可以保证数据的正确性。如果有多个读写用户访问环形缓冲区，那么必须添加互斥保护机制来确保多个用户互斥访问环形缓冲区。 2.程序 #include "CRingBuffer.h" #in
循环buffer的c++实现
张利 的博客
04-26 1150
实现一个循环buffer, 新数据会覆盖旧数据 RingBuffer.h #pragma once #include <stdio.h> #include <string.h> class RingBuffer { public: RingBuffer() { size = 0; } ~RingBuffer() { if (buffer) { d...
循环缓存区之C++实现
zmyer的专栏
02-26 4205
最近，在优化服务器端底层代码时，遇到了一个比较影响系统性能的东西——缓存区，最已有的方案里，其采用了单缓冲区，每次需要空间时，都会检查缓冲区空闲空间是否满足，如果满足还得进行移动内存的操作（想必搞过服务器开发的同事，这点深有体会吧），当数据交换量猛增时，这个方案效果立马显现，于是自己私下写了一个简单版的循环缓存，原理很简单，在这之上自己将代码进行了规整和优化，并替换了原来的单缓存区方案，效果显著，
用C++实现一个循环缓冲
最新发布
04-11
循环缓冲区通常使用一个指针和一个数组实现，具体过程如下： 1.首先定义一个数组和两个指针：buffer、head和tail。 2.数组用来存储数据，head和tail分别表示写入和读取位置的指针。 3.循环缓冲区的大小是有限的，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值