C++——一个封装好的环形缓冲区

最新推荐文章于 2024-04-23 04:33:05 发布
最新推荐文章于 2024-04-23 04:33:05 发布
阅读量961 收藏
点赞数
文章标签： c++ delete class null c 2010
/*-------------------------
002 * Author: XadillaX       |
003 * Data: 2010/10/3        |
004 * Class: CircleBuffer    |
005 *------------------------|---*/
006  
007#ifndef CircleBuffer_H
008#define CircleBuffer_H
009  
010#ifndef SAFEDEL(p)
011  #define SAFEDEL(p) { delete p; p = NULL; }
012#endif
013  
014/*
015 * 类：环形缓冲区
016 */
017template<typename ElemType>
018class CircleBuffer {
019private:
020    ElemType *Arr;
021    int _l;
022    int _c;
023    int _size;
024    int _cnt;
025  
026    int conv(int i);
027public:
028    CircleBuffer(int MaxSize = 65535);
029    ~CircleBuffer();
030  
031    bool push(ElemType ele);
032    void clear();
033    bool pop(ElemType &ele);
034    bool empty();
035    int count();
036    int GetSize();
037};
038  
039/*
040 * 实现环形缓冲区
041 */
042template<typename ElemType>
043CircleBuffer<ElemType>::CircleBuffer(int MaxSize) : _size(MaxSize)
044{
045    if(_size < 1) _size = 1;
046    Arr = new ElemType[MaxSize];
047    _l = _c = _size - 1;
048    _cnt = 0;
049}
050  
051template<typename ElemType>
052CircleBuffer<ElemType>::~CircleBuffer()
053{
054    delete []Arr;
055    Arr = NULL;
056}
057  
058template<typename ElemType>
059int CircleBuffer<ElemType>::conv(int i)
060{
061    return (i < _size) ? i : 0;
062}
063  
064template<typename ElemType>
065bool CircleBuffer<ElemType>::push(ElemType ele)
066{
067    if(_cnt < _size)
068    {
069        _l = conv(_l + 1);
070        Arr[_l] = ele;
071        _cnt++;
072  
073        return true;
074    }
075    else return false;
076}
077  
078template<typename ElemType>
079bool CircleBuffer<ElemType>::pop(ElemType &ele)
080{
081    if(_cnt == 0) return false;
082    else
083    {
084        _cnt--;
085        _c = conv(_c + 1);
086        ele = Arr[_c];
087        return true;
088    }
089}
090  
091template<typename ElemType>
092int CircleBuffer<ElemType>::count()
093{
094    return _cnt;
095}
096  
097template<typename ElemType>
098bool CircleBuffer<ElemType>::empty()
099{
100    if(!_cnt) return true;
101    else return false;
102}
103  
104template<typename ElemType>
105int CircleBuffer<ElemType>::GetSize()
106{
107    return _size;
108}
109  
110template<typename ElemType>
111void CircleBuffer<ElemType>::clear()
112{
113    _l = _c = _size - 1;
114    _cnt = 0;
115}
116#endif
/*-------------------------
002 * Author: XadillaX       |
003 * Data: 2010/10/3        |
004 * Class: CircleBuffer    |
005 *------------------------|---*/
006  
007#ifndef CircleBuffer_H
008#define CircleBuffer_H
009  
010#ifndef SAFEDEL(p)
011  #define SAFEDEL(p) { delete p; p = NULL; }
012#endif
013  
014/*
015 * 类：环形缓冲区
016 */
017template<typename ElemType>
018class CircleBuffer {
019private:
020    ElemType *Arr;
021    int _l;
022    int _c;
023    int _size;
024    int _cnt;
025  
026    int conv(int i);
027public:
028    CircleBuffer(int MaxSize = 65535);
029    ~CircleBuffer();
030  
031    bool push(ElemType ele);
032    void clear();
033    bool pop(ElemType &ele);
034    bool empty();
035    int count();
036    int GetSize();
037};
038  
039/*
040 * 实现环形缓冲区
041 */
042template<typename ElemType>
043CircleBuffer<ElemType>::CircleBuffer(int MaxSize) : _size(MaxSize)
044{
045    if(_size < 1) _size = 1;
046    Arr = new ElemType[MaxSize];
047    _l = _c = _size - 1;
048    _cnt = 0;
049}
050  
051template<typename ElemType>
052CircleBuffer<ElemType>::~CircleBuffer()
053{
054    delete []Arr;
055    Arr = NULL;
056}
057  
058template<typename ElemType>
059int CircleBuffer<ElemType>::conv(int i)
060{
061    return (i < _size) ? i : 0;
062}
063  
064template<typename ElemType>
065bool CircleBuffer<ElemType>::push(ElemType ele)
066{
067    if(_cnt < _size)
068    {
069        _l = conv(_l + 1);
070        Arr[_l] = ele;
071        _cnt++;
072  
073        return true;
074    }
075    else return false;
076}
077  
078template<typename ElemType>
079bool CircleBuffer<ElemType>::pop(ElemType &ele)
080{
081    if(_cnt == 0) return false;
082    else
083    {
084        _cnt--;
085        _c = conv(_c + 1);
086        ele = Arr[_c];
087        return true;
088    }
089}
090  
091template<typename ElemType>
092int CircleBuffer<ElemType>::count()
093{
094    return _cnt;
095}
096  
097template<typename ElemType>
098bool CircleBuffer<ElemType>::empty()
099{
100    if(!_cnt) return true;
101    else return false;
102}
103  
104template<typename ElemType>
105int CircleBuffer<ElemType>::GetSize()
106{
107    return _size;
108}
109  
110template<typename ElemType>
111void CircleBuffer<ElemType>::clear()
112{
113    _l = _c = _size - 1;
114    _cnt = 0;
115}
116#endif
/*-------------------------
002 * Author: XadillaX       |
003 * Data: 2010/10/3        |
004 * Class: CircleBuffer    |
005 *------------------------|---*/
006  
007#ifndef CircleBuffer_H
008#define CircleBuffer_H
009  
010#ifndef SAFEDEL(p)
011  #define SAFEDEL(p) { delete p; p = NULL; }
012#endif
013  
014/*
015 * 类：环形缓冲区
016 */
017template<typename ElemType>
018class CircleBuffer {
019private:
020    ElemType *Arr;
021    int _l;
022    int _c;
023    int _size;
024    int _cnt;
025  
026    int conv(int i);
027public:
028    CircleBuffer(int MaxSize = 65535);
029    ~CircleBuffer();
030  
031    bool push(ElemType ele);
032    void clear();
033    bool pop(ElemType &ele);
034    bool empty();
035    int count();
036    int GetSize();
037};
038  
039/*
040 * 实现环形缓冲区
041 */
042template<typename ElemType>
043CircleBuffer<ElemType>::CircleBuffer(int MaxSize) : _size(MaxSize)
044{
045    if(_size < 1) _size = 1;
046    Arr = new ElemType[MaxSize];
047    _l = _c = _size - 1;
048    _cnt = 0;
049}
050  
051template<typename ElemType>
052CircleBuffer<ElemType>::~CircleBuffer()
053{
054    delete []Arr;
055    Arr = NULL;
056}
057  
058template<typename ElemType>
059int CircleBuffer<ElemType>::conv(int i)
060{
061    return (i < _size) ? i : 0;
062}
063  
064template<typename ElemType>
065bool CircleBuffer<ElemType>::push(ElemType ele)
066{
067    if(_cnt < _size)
068    {
069        _l = conv(_l + 1);
070        Arr[_l] = ele;
071        _cnt++;
072  
073        return true;
074    }
075    else return false;
076}
077  
078template<typename ElemType>
079bool CircleBuffer<ElemType>::pop(ElemType &ele)
080{
081    if(_cnt == 0) return false;
082    else
083    {
084        _cnt--;
085        _c = conv(_c + 1);
086        ele = Arr[_c];
087        return true;
088    }
089}
090  
091template<typename ElemType>
092int CircleBuffer<ElemType>::count()
093{
094    return _cnt;
095}
096  
097template<typename ElemType>
098bool CircleBuffer<ElemType>::empty()
099{
100    if(!_cnt) return true;
101    else return false;
102}
103  
104template<typename ElemType>
105int CircleBuffer<ElemType>::GetSize()
106{
107    return _size;
108}
109  
110template<typename ElemType>
111void CircleBuffer<ElemType>::clear()
112{
113    _l = _c = _size - 1;
114    _cnt = 0;
115}
116#endif

相当于队列。但是因为要涉及不断的创建、释放指针，所以会导致系统不稳定。环形缓冲区就事先创建好一片缓冲区。适用于网

络服务器被连接。

/*------------------------- 

002  * Author: XadillaX       | 

003  * Data: 2010/10/3        | 

004  * Class: CircleBuffer    | 

005  *------------------------|---*/

006   

007 #ifndef CircleBuffer_H 

008 #define CircleBuffer_H 

009   

010 #ifndef SAFEDEL(p) 

011   #define SAFEDEL(p) { delete p; p = NULL; } 

012 #endif 

013   

014 /* 

015  * 类：环形缓冲区 

016  */

017 template<typename ElemType> 

018 class CircleBuffer { 

019 private: 

020     ElemType *Arr; 

021     int _l; 

022     int _c; 

023     int _size; 

024     int _cnt; 

025   

026     int conv(int i); 

027 public: 

028     CircleBuffer(int MaxSize = 65535); 

029     ~CircleBuffer(); 

030   

031     bool push(ElemType ele); 

032     void clear(); 

033     bool pop(ElemType &ele); 

034     bool empty(); 

035     int count(); 

036     int GetSize(); 

037 }; 

038   

039 /* 

040  * 实现环形缓冲区 

041  */

042 template<typename ElemType> 

043 CircleBuffer<ElemType>::CircleBuffer(int MaxSize) : _size

(MaxSize) 

044 { 

045     if(_size < 1) _size = 1; 

046     Arr = new ElemType[MaxSize]; 

047     _l = _c = _size - 1; 

048     _cnt = 0; 

049 } 

050   

051 template<typename ElemType> 

052 CircleBuffer<ElemType>::~CircleBuffer() 

053 { 

054     delete []Arr; 

055     Arr = NULL; 

056 } 

057   

058 template<typename ElemType> 

059 int CircleBuffer<ElemType>::conv(int i) 

060 { 

061     return (i < _size) ? i : 0; 

062 } 

063   

064 template<typename ElemType> 

065 bool CircleBuffer<ElemType>::push(ElemType ele) 

066 { 

067     if(_cnt < _size) 

068     { 

069         _l = conv(_l + 1); 

070         Arr[_l] = ele; 

071         _cnt++; 

072   

073         return true; 

074     } 

075     else return false; 

076 } 

077   

078 template<typename ElemType> 

079 bool CircleBuffer<ElemType>::pop(ElemType &ele) 

080 { 

081     if(_cnt == 0) return false; 

082     else

083     { 

084         _cnt--; 

085         _c = conv(_c + 1); 

086         ele = Arr[_c]; 

087         return true; 

088     } 

089 } 

090   

091 template<typename ElemType> 

092 int CircleBuffer<ElemType>::count() 

093 { 

094     return _cnt; 

095 } 

096   

097 template<typename ElemType> 

098 bool CircleBuffer<ElemType>::empty() 

099 { 

100     if(!_cnt) return true; 

101     else return false; 

102 } 

103   

104 template<typename ElemType> 

105 int CircleBuffer<ElemType>::GetSize() 

106 { 

107     return _size; 

108 } 

109   

110 template<typename ElemType> 

111 void CircleBuffer<ElemType>::clear() 

112 { 

113     _l = _c = _size - 1; 

114     _cnt = 0; 

115 } 

116 #endif

 

zenglinghai888888
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一个c++环形队列缓冲区
11-30
环形缓冲区读写操作的分析与实现，以及在并发条件下如何控制竞争
C语言构建环形缓冲区
Leon的博客
08-29 5636
它逻辑上是一个首尾相连的FIFO结构，具体实现上采用简单的线性数组。通过额外的辅助标志（head、tail）能很快知道队列的使用情况（是满还是为空）。正因为其简单高效的原因，甚至在硬件都实现了环形队列。 环形队列广泛用于网络数据收发、程序间的大量数据交换（比如内核与应用程）、硬件接收大量数据。 1、环形缓冲区原理 环列队列逻辑上将数组元素array[0]与array[LEN-1]连接起来，形成一个存放队列的环形空间。实际操作中为了方便读写，采用head和tail分别指向可以读的位置和可以写的位置。 环形
c语言环形存储,环形缓存区bufferC语言实现
weixin_39618824的博客
05-18 1239
buffer[iput]=z;iput = addring(iput);n++;}elseprintf(“Buffer is full\n”);}int main{void){chat opera[5];double z;do {printf(“Please input p|g|e?”);scanf(“%s”, &opera);switch(tolower(opera[0])){case ...
环形缓冲区
热门推荐
蜜汁程序员的博客
10-20 2万+
https://blog.csdn.net/p23onzq/article/details/80750745 .https://blog.csdn.net/blade2001/article/details/7094232/ 正在造轮子，同时不停地在找哪里有这个轮子 原因： 当有大量数据的时候，我们不能存储所有的数据，那么计算机处理数据的时候，只能先处理先来的，那么处理完后呢，就会把数据释...
C++环形缓冲区
Lao_tan的博客
06-27 3224
C++实现环形缓冲区
C++ 环形缓冲区RingBuffer 简单实现
搬砖小能手
02-18 1万+
C++环形缓冲区RingBuffer的简单实现
Boost::circular_buffer——循环缓冲区
华秋实的专栏
03-22 1万+
一、概述Boost.Circular_buffer维护了一块连续内存块作为缓存区，当缓存区内的数据存满时，继续存入数据就覆盖掉旧的数据。 它是一个与STL兼容的容器，类似于 std::list或std::deque,并且支持随机存取。circular_buffer 被特别设计为提供固定容量的存储大小。当其容量被用完时，新插入的元素会覆盖缓冲区头部或尾部(取决于使用何种插入操作)的元素。逻辑存储结构
Boost无锁队列
罗布泊coding
03-24 1万+
在开发接收转发agent时，采用了多线程的生产者-消费者模式，用了加互斥锁的方式来实现线程同步。互斥锁会阻塞线程，所以压测时，效率并不高。所以想起用无锁队列来实现，性能确实提升了。一. 用互斥锁实现单生产者-单消费者#include &lt;string&gt; #include &lt;sstream&gt; #include &lt;list&gt; #include &lt;pthread.h&gt; #include &lt;i
博弈树 c++ 实现五子棋
m0_62695927的博客
11-01 725
if (a->x[i][j] == 1 )//横向该棋子被访问则不在访问。vectorcunchu(cell* a) {//找到待拓展的节点。int evaluate(cell* a) {//对局势进行评估。int expand_pos(cell* a) {//生成子树。
boost循环队列 circular_buffer
信箱神、得引擎
10-19 3408
用法 适合用于固定空间位置及大小的情况 构造函数必须传入初始队列大小支持下标引用，0表示队头位置，而不是队列空间的起始位置，中间某个下标会自动跨过队列空间的结束位置支持begin、end等常用stl iterator用法删除队头附近的元素使用rerase(iterator, iterator)，会将队头到iterator之间（如果有）的值往后移circular_buffer::ar
boost 环形无锁队列实现的 定制化内存池
smalbig的博客
06-09 485
近期要做图片数据（大小4096 x 4096 x 3）入队缓冲的的功能，首先考虑用一个boost无锁队列进行缓冲，问题是需要频繁的 malloc 和 free，对系统性能有影响，所以考虑内存池的方式来管理内存。 参考了boost的内存池，发现和我的程序框架揉不起来，不知道怎么在类里声明一个内存池，然后在函数里初始化他。 所以考虑用两个无锁队列来实现 内存池+无锁队列 的缓冲方式。 内存池用的无锁队列： struct imageStruct { int m_width; int m_height;
CircleBuffer 环形缓冲区
03-29
模板类名：CircleBuffer 功 能：环形缓冲区 优 点：相对于队列来说减少了很多对地址的反复操作，增加稳定性。
C++环形缓冲区模板代码
11-30
一个C++缓冲区模板类,循环队列实现，循环法抛弃最先进缓冲区的数据
一个封装好的C++环形缓冲区
11-30
用C++封装好的一个环形缓冲区代码，各位需要的可以拿去
一个好玩的c++游戏——生死枪战！
07-27
生死枪战游戏目前以3个模式运行（持续更新），玩家可以通过自己的喜好来选择，如：新手训练营，无限闯关，打怪，以及能调用时间而改变战力的暗月阁长老。更多特殊技能、特殊武器等你发掘！ 改进或交流该游戏的建议...
基于C++的环形缓冲区.zip
09-01
一种基于c++实现的环形缓冲区，可根据需求任意设定缓冲区大小，包括定长缓冲区和变长缓冲区。经过项目实际应用，高效、可靠。
数据结构与算法学习笔记七--二叉树(C++)
最新发布
我叫柱子哥
04-23 507
在计算机科学中，树（Tree）是一种抽象数据类型，用于模拟具有树状结构特征的数据集合。树是由一组节点（Nodes）和连接这些节点的边（Edges）组成的，其中一个节点被指定为根节点（Root），其余节点分层组织成子树（Subtrees）。树的每个节点除了根节点外，都恰好连接到一条来自另一个节点的边，这个节点被称为其父节点（Parent Node）。每个节点可以连接到零个或多个子节点，子节点的节点被称为父节点的孩子节点（Child Node）。根节点（Root）：树中的唯一顶层节点，没有父节点。
C语言：贪吃蛇游戏（万字解读超详细）
2301_80655639的博客
04-20 923
贪吃蛇这个游戏应该我们小时候都玩过吧我相信能够点进这个博客的应该都很熟悉这个游戏了如果对这个游戏不熟悉的可以网上查查怎么玩，这样才能对这个游戏有个清晰的认知该篇博客需要拥有C语言基础（对指针熟悉、会链表的使用）下面我们需要先学习一些C语言之外的东西认真坚持看完，我相信你一定能完成这个接近500行的C语言贪吃蛇项目该类型内部封装了两个成员，一个x，一个y，代表坐标我们可以将我们的控制台理解为一个平面坐标图横向正方向是x轴正方向，竖向负方向是y轴正方向。
c++环形缓冲区 不加锁
06-09
对于一个环形缓冲区而言，如果只有一个生产者和一个消费者，是可以不加锁的。因为生产者和消费者都只会在各自的位置上进行读写操作，不会相互干扰。但是如果有多个生产者或消费者，就需要加锁保证线程安全了。常见的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值