C++版循环缓冲区类

最新推荐文章于 2023-05-28 02:00:07 发布
最新推荐文章于 2023-05-28 02:00:07 发布
阅读量5.5k 收藏 16
点赞数
分类专栏： 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());
        }
    }


大招至胜
关注
  • 0
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
C++环形缓冲区模板代码
11-30
一个C++缓冲区模板类,循环队列实现，循环法抛弃最先进缓冲区的数据
循环buffer
08-23
C++实现的两种方式的循环Buffer，一种需要拷贝4次，一种需要拷贝2次，支持两线程间的读写，还可以改为两进程间的读写（需要修改成进程间的互斥方式）
C++封装 循环缓冲区
11-23
C++ 封装的循环缓冲区类，可扩展，用于视频接收缓存区、消息接收缓冲区、解析数据缓冲区
循环缓冲区C++
04-30
循环缓冲区，采用C++开发。 实现了数据的读写操作。
一种可用于流媒体传输的循环缓冲区的VC++实现
12-16
应用背景： 此循环缓冲区用于缓冲实时流媒体数据，以不定长度的数据块为存取单位，符合FIFO规则。 特征： 1、封装成了一个类，便于代码重用； 2、采用Mutex作为读取同步机制； 3、可设置缓冲区内的最多块的数量；
【C++】31. Boost::circular_buffer——循环缓冲区
u011754972的博客
05-31 917
一、概述 Boost.Circular_buffer维护了一块连续内存块作为缓存区，当缓存区内的数据存满时，继续存入数据就覆盖掉旧的数据。 它是一个与STL兼容的容器，类似于 std::list或std::deque,并且支持随机存取。circular_buffer 被特别设计为...
c++缓冲区buffer
jacke121的专栏
02-15 4833
c++缓冲区buffer
C语言版本的循环buffer比C++版本的速度更快！测试500M数据0.5秒，达9.25Gbps左右！
weixin_46564301的博客
03-04 486
使用随机生成一个500M的源数据文件，开启两个线程，一个线程从数据文件中随机长度读取数据，然后往循环buffer里面写数据，一个线程从循环buffer里面随机长度读取出数据，然后写入文件，最后使用。速率：注意，测试速率时候把read_data_task线程函数的写文件给注释了，因为我们测的速率只是循环buffer接口的性能。中实现了C++版本的循环buffer，这次分享一个C语言版本的循环buffer，程序设计逻辑与上一个版本完全一致，只是改用了C语言并通过函数指针进行封装。接下来直接进入正题--
C++环形缓冲区
Lao_tan的博客
06-27 3224
C++实现环形缓冲区
循环buffer的实现
justkong的博客
08-07 3596
1.循环buffer的特点 1、先进先出 2、当空闲缓冲区用完，且又有新的数据需要存储时，覆盖历史数据，保存新的数据 3、环形缓冲区在实现时采用的是线型的存储结构 4、线型存储中需要四个指针，分别为缓冲区首地址指针（pHead）、尾地址指针（pTail）、有效数据起始指针（pValid）、有效数据尾指针（pValidTail）。其中pValid<pValidTail或者pValid...
C实现循环缓冲区，线程交替执行，进行数据读取
05-09
循环缓冲区，线程交替执行进行数据读取
【C++模块实现】| 【08】循环覆盖写内存缓冲区（日志中多线程记录）
weixin_45926547的博客
08-01 906
循环缓冲区(也称为环形缓冲区)是固定大小的缓冲区，工作原理就像内存是连续的且可循环的一样；-在生成和使用内存时，不需将原来的数据全部重新清理掉，只要调整head/tail指针即可；-当添加数据时，head指针前进。当使用数据时，tail指针向前移动；-当到达缓冲区的尾部时，指针又回到缓冲区的起始位置；...
循环缓冲区的实现（纯C）
weixin_40882562的博客
08-11 2049
循环缓冲区的用途 循环缓冲区主要用在文件系统中，和FIFO队列进行互补，特点是读写指针互不干扰，适用于经典的生产者消费者问题,相关原理已有相关博主解释。 循环缓冲区的定义 struct TRingBuf { char *buf; char *end_pos_; char *read_pos_; char *write_pos_; //int data_siz...
[嵌入式开发模块]环形缓冲区/循环队列 C语言实现
热门推荐
夏日白云的boke
06-22 1万+
忙着毕设，很久没有写文章了，终于答辩完了，得了个校优秀毕业设计。毕设做的是个智能接口模块，用一周时间入门了，MC9S12XEP100的开发，又用一周时间入门了uC/OS-II嵌入式操作系统，在做毕设的过程中学到了很多，现在把一些工具发上来分享。 这里分享一个自己用纯C实现的环形缓冲区。环形缓冲区有很多作用，比如嵌入式中的通信可以用环形缓冲区作为信道，一个线程往里放字节，一个线程取字节进行处理...
通用循环缓冲区类(c++版)
xujunjie的专栏
04-09 1431
// 声明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 501
CCycleBuffer.h #ifndef __test__CCycleBuffer__ #define __test__CCycleBuffer__ #include <iostream> #include <assert.h> class CCycleBuffer { public: bool isFull(); bool isEmpty();...
C++环形缓冲区设计与实现：从原理到应用的全方位解析
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
05-28 2132
C++环形缓冲区设计与实现：从原理到应用的全方位解析
c和c++的循环buffer
weixin_42403965的博客
06-01 542
这是循环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
STM32串口循环缓冲区
最新发布
07-14
在STM32微控制器上实现串口循环缓冲区是一种常见的方法，可以有效地处理串口接收和发送数据。 循环缓冲区是一种环形数据结构，使用一个固定大小的缓冲区来存储数据。当数据写入缓冲区时，指针会向前移动，直到达到缓冲区的末尾，然后再从缓冲区的开头继续写入数据。这样可以实现无限循环的数据存储。 以下是一个简单的示例代码，演示了如何在STM32上实现串口循环缓冲区： ```c #define BUFFER_SIZE 256 volatile uint8_t rx_buffer[BUFFER_SIZE]; volatile uint8_t tx_buffer[BUFFER_SIZE]; volatile uint16_t rx_buffer_head = 0; volatile uint16_t rx_buffer_tail = 0; volatile uint16_t tx_buffer_head = 0; volatile uint16_t tx_buffer_tail = 0; void USART1_IRQHandler(void) { if (USART1->SR & USART_SR_RXNE) { // 读取接收到的数据 uint8_t data = USART1->DR; // 将数据写入接收缓冲区 rx_buffer[rx_buffer_head] = data; rx_buffer_head = (rx_buffer_head + 1) % BUFFER_SIZE; } if (USART1->SR & USART_SR_TXE) { if (tx_buffer_head != tx_buffer_tail) { // 从发送缓冲区读取数据并发送 uint8_t data = tx_buffer[tx_buffer_tail]; USART1->DR = data; tx_buffer_tail = (tx_buffer_tail + 1) % BUFFER_SIZE; } else { // 发送缓冲区为空，禁用发送中断 USART1->CR1 &= ~USART_CR1_TXEIE; } } } void USART1_SendData(uint8_t data) { // 将数据写入发送缓冲区 tx_buffer[tx_buffer_head] = data; tx_buffer_head = (tx_buffer_head + 1) % BUFFER_SIZE; // 启用发送中断 USART1->CR1 |= USART_CR1_TXEIE; } uint8_t USART1_ReceiveData(void) { uint8_t data = rx_buffer[rx_buffer_tail]; rx_buffer_tail = (rx_buffer_tail + 1) % BUFFER_SIZE; return data; } int main(void) { // 初始化串口 USART1->CR1 |= USART_CR1_RXNEIE; // 启用接收中断 NVIC_EnableIRQ(USART1_IRQn); while (1) { // 接收并处理数据 if (rx_buffer_head != rx_buffer_tail) { uint8_t data = USART1_ReceiveData(); // 处理接收到的数据 } // 发送数据 // ... } } ``` 在上面的示例代码中，我们使用了两个缓冲区 `rx_buffer` 和 `tx_buffer` 分别用于接收和发送数据。通过中断处理函数 `USART1_IRQHandler`，我们将接收到的数据存储在接收缓冲区中，并将发送缓冲区的数据发送出去。 在主循环中，我们可以通过调用 `USART1_ReceiveData` 函数来读取接收缓冲区中的数据，并进行相应的处理。同时，我们也可以通过调用 `USART1_SendData` 函数将数据写入发送缓冲区，并由中断处理函数将数据发送出去。 这只是一个简单的例子，实际应用中可能需要更多的功能和细节处理，但这可以作为一个起点来实现串口循环缓冲区。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值