C++版循环缓冲区类

最新推荐文章于 2022-08-01 17:27:24 发布
最新推荐文章于 2022-08-01 17:27:24 发布
阅读量5.5k 收藏 15
点赞数
分类专栏： C/C++ 文章标签： c++ delete class c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/devday/article/details/5258697
版权

 

上面这个版本是windows C++版，下面的是标准C++版

#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__) */

#include "CCycleBuffer.h"
// 定义
CCycleBuffer::CCycleBuffer(int size)
{
    m_nBufSize = size;
    m_nReadPos = 0;
    m_nWritePos = 0;
    m_pBuf = new char[m_nBufSize];
    m_bEmpty = true;
    m_bFull = false;
}
CCycleBuffer::~CCycleBuffer()
{
    delete[] m_pBuf;
}
/************************************************************************/
/* 向缓冲区写入数据，返回实际写入的字节数                               */
/************************************************************************/
int CCycleBuffer::Write(char* buf, int count)
{
    if(count <= 0) return 0;
    m_bEmpty = false;
    // 缓冲区已满，不能继续写入
    if(m_bFull)
    {
        return 0;
    }
    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;
        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 = (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) return 0;
    m_bFull = false;
    if(m_bEmpty)       // 缓冲区空，不能继续读取数据
    {
        return 0;
    }
    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, 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)  
    {  
        return 0;  
    }  
    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;  
}


增加一个Objective_c的测试用例

    int* dataint = new int[10]();
    CCycleBuffer buffer(100);
    char* datachar = (char *)dataint;
    int* resint = new int[10]();
    char* reschar = (char*)resint;
    int num = 0;
    while(1)
    {
        int a = 0;
        if(buffer.GetLength()<60)
        {
            dataint[0] = num;
            //qDebug("write 之前 m_nReadPos:%d,m_nWritePos:%d,Length:%d",buffer.getStart(),buffer.getEnd(),buffer.getLength());
            a = buffer.Write(datachar,10*4);
            if(a<=0)
                NSLog(@"写失败");
            NSLog(@"write %d之后 m_nReadPos:%d,m_nWritePos:%d,Length:%d", a, buffer.GetReadPos() , buffer.GetWritePos(),buffer.GetLength());
            num++;
        }
        if(buffer.GetLength()<60)
        {
            dataint[0] = num;
            NSLog(@"write 之前 m_nReadPos:%d,m_nWritePos:%d,Length:%d", buffer.GetReadPos() , buffer.GetWritePos(),buffer.GetLength());
            a = buffer.Write(datachar,10*4);
            if(a<=0)
                NSLog(@"写失败");
            NSLog(@"write %d之后 m_nReadPos:%d,m_nWritePos:%d,Length:%d", a, buffer.GetReadPos() , buffer.GetWritePos(),buffer.GetLength());
            num++;
        }
        if(buffer.GetLength()>=10*4)
        {
            NSLog(@"read 之前 m_nReadPos:%d,m_nWritePos:%d,Length:%d", buffer.GetReadPos() , buffer.GetWritePos(),buffer.GetLength());
            a = buffer.Read(reschar,10*4);
            NSLog(@"read %d之后 m_nReadPos:%d,m_nWritePos:%d,Length:%d", a, buffer.GetReadPos() , buffer.GetWritePos(),buffer.GetLength());
        }
    }


大招至胜
关注
专栏目录
通用循环缓冲区类(c++版)
xujunjie的专栏
04-09 1471
// 声明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++版循环缓冲
grandgrandpa的博客
12-02 543
CCycleBuffer.h #ifndef __test__CCycleBuffer__ #define __test__CCycleBuffer__ #include <iostream> #include <assert.h> class CCycleBuffer { public: bool isFull(); bool isEmpty();...
linux c++循环缓冲区模板类
07-26 214
一：概述 实际学习和工作中，我们经常会遇到读写大量数据的情况，这个时候我们可能就用到了循环缓冲区。 循环缓冲区在处理大量数据的时候有很大的优点，循环缓冲区在一些竞争问题上提供了一种免锁的机制，免锁的前提是，生产者和消费都只有一个的情况下，否则也要加锁。 二：循环缓冲区的实现理论如下图 三：实现代码如下所示： //CRecycleQueue.h #include&l...
C++封装 循环缓冲区
11-23
C++ 封装的循环缓冲区类，可扩展，用于视频接收缓存区、消息接收缓冲区、解析数据缓冲区
循环缓冲区C++
04-30
在C++中，我们可以自定义一个循环缓冲区类来实现这一功能。下面将详细阐述循环缓冲区的工作原理、设计与实现，并结合C++代码进行解析。 循环缓冲区的核心思想是利用数组的首尾相连，形成一个环状的存储空间。当数据...
无锁循环缓冲区的实现c语言,C++ 无锁环形缓冲区实现
weixin_35403151的博客
05-20 572
前段时间有个项目要实现一个基于live555的rtspserver，部分功能要用到环形缓冲区，网上看了一些blog，大部分是实验性质的，不太敢用，原理比较简单，所以就自己写了一个；实现环形缓冲区的关键点：1. 一个线程读，一个线程写2. 读线程维护读指针，写线程维护写指针3.数据一致性3.1 写线程写数据时，要先确定读指针；读线程读数据时，要先确定写指针；这里写的可能比较拗口，其实就是 写线程写...
一种可用于流媒体传输的循环缓冲区的VC++实现
03-02
此循环缓冲区用于缓冲实时流媒体数据，以不定长度的数据块为存取单位，符合FIFO规则。 特征： 1、封装成了一个类，便于代码重用； 2、采用Mutex作为读取同步机制； 3、可设置缓冲区内的最多块的数量；
循环缓冲区c++
random_liu_2013
08-30 324
template<typename T,int N> class RingBuf { public: RingBuf() : capSize(N){ first = last = 0; size = 0; } ~RingBuf() { } bool get(T& a) { if (is...
循环buffer
08-23
C++实现的两种方式的循环Buffer，一种需要拷贝4次，一种需要拷贝2次，支持两线程间的读写，还可以改为两进程间的读写（需要修改成进程间的互斥方式）
【C++】31. Boost::circular_buffer——循环缓冲区
u011754972的博客
05-31 981
一、概述 Boost.Circular_buffer维护了一块连续内存块作为缓存区，当缓存区内的数据存满时，继续存入数据就覆盖掉旧的数据。 它是一个与STL兼容的容器，类似于 std::list或std::deque,并且支持随机存取。circular_buffer 被特别设计为...
C++版的循环缓冲区类（实际测试可用！）
RationalGo的专栏
07-27 1022
[cpp] view plaincopy /*   * CCycleBuffer.h   *   *  Created on: 2013-5-27   *      Author: shiguang   */      #ifndef __test__CCycleBuffer__   #define __test__CCycleBuffer__  
linux 下面实现c++实现循环缓冲区（1）
qq_39971579的博客
01-23 541
1.循环缓冲区的原理 环形缓冲区通常有一个读指针和一个写指针。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区中可写的缓冲区。通过移动读指针和写指针就可以实现缓冲区的数据读取和写入。在通常情况下，环形缓冲区的读用户仅仅会影响读指针，而写用户仅仅会影响写指针。如果仅仅有一个读用户和一个写用户，那么不需要添加互斥保护机制就可以保证数据的正确性。如果有多个读写用户访问环形缓冲区，那么必须添加互斥保护机制来确保多个用户互斥访问环形缓冲区。 2.程序 #include "CRingBuffer.h" #in
循环缓冲区C++的一种实现
青春不谢的专栏
09-09 3253
之前去腾讯面试的时候被问到的一道题目：实现一个循环缓冲区（不带互斥锁）。仔细一想，其实和循环队列的思想一模一样，还是怪自己数据结构没学好阿（其实我是学通信的，所以最近在恶补）。还是先上代码 头文件如下，CircleBuffer.h #ifndef _CIRCLE_BUFFER_H_ #define _CIRCLE_BUFFER_H_ //basic data type rename ty
【C++模块实现】| 【08】循环覆盖写内存缓冲区（日志中多线程记录）
weixin_45926547的博客
08-01 964
循环缓冲区(也称为环形缓冲区)是固定大小的缓冲区，工作原理就像内存是连续的且可循环的一样；-在生成和使用内存时，不需将原来的数据全部重新清理掉，只要调整head/tail指针即可；-当添加数据时，head指针前进。当使用数据时，tail指针向前移动；-当到达缓冲区的尾部时，指针又回到缓冲区的起始位置；...
循环缓存区之C++实现
zmyer的专栏
02-26 4205
最近，在优化服务器端底层代码时，遇到了一个比较影响系统性能的东西——缓存区，最已有的方案里，其采用了单缓冲区，每次需要空间时，都会检查缓冲区空闲空间是否满足，如果满足还得进行移动内存的操作（想必搞过服务器开发的同事，这点深有体会吧），当数据交换量猛增时，这个方案效果立马显现，于是自己私下写了一个简单版的循环缓存，原理很简单，在这之上自己将代码进行了规整和优化，并替换了原来的单缓存区方案，效果显著，
C++ 循环缓冲类
weixin_38169359的博客
05-08 124
昨天看到博客园有个面试者笔试出现此题，昨天大概给出思路，今天经过思考将实现，并做出优化改进 ，逻辑易懂，基本都可以看懂，经过初步测试正确。代码如下： 1 // MindryBuffer.cpp : 定义控制台应用程序的入口点。 2 // 3 4 #include "stdafx.h" 5 #include <iostream> 6 #...
c和c++的循环buffer
weixin_42403965的博客
06-01 629
这是循环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++实现环形缓冲区模板类
"C++环形缓冲区模板代码是一个实现循环队列的C++类，用于高效存储和检索数据。该模板类支持不同类型的元素，包括但不限于基本类型和自定义对象。环形缓冲区在内存中形成一个固定大小的循环数组，当缓冲区满时，最先...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值