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

来源：互联网发布：python 列表元组结合编辑：程序博客网时间：2024/05/11 00:40

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

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<typenameElemType>

018class CircleBuffer {

019private:

020 ElemType *Arr;

021 int_l;

022 int_c;

023 int_size;

024 int_cnt;

025

026 intconv(int i);

027public:

028 CircleBuffer(intMaxSize = 65535);

029 ~CircleBuffer();

030

031 boolpush(ElemType ele);

032 voidclear();

033 boolpop(ElemType &ele);

034 boolempty();

035 intcount();

036 intGetSize();

037};

038

039/*

040 * 实现环形缓冲区

041 */

042template<typenameElemType>

043CircleBuffer<ElemType>::CircleBuffer(intMaxSize) : _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<typenameElemType>

052CircleBuffer<ElemType>::~CircleBuffer()

053{

054 delete[]Arr;

055 Arr = NULL;

056}

057

058template<typenameElemType>

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

060{

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

062}

063

064template<typenameElemType>

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 returntrue;

074 }

075 elsereturn false;

076}

077

078template<typenameElemType>

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 returntrue;

088 }

089}

090

091template<typenameElemType>

092int CircleBuffer<ElemType>::count()

093{

094 return_cnt;

095}

096

097template<typenameElemType>

098bool CircleBuffer<ElemType>::empty()

099{

100 if(!_cnt)return true;

101 elsereturn false;

102}

103

104template<typenameElemType>

105int CircleBuffer<ElemType>::GetSize()

106{

107 return_size;

108}

109

110template<typenameElemType>

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<typenameElemType> 
018class CircleBuffer { 
019private:
020    ElemType *Arr;
021    int_l; 
022    int_c; 
023    int_size; 
024    int_cnt; 
025  
026    intconv(int i); 
027public:
028    CircleBuffer(intMaxSize = 65535); 
029    ~CircleBuffer();
030  
031    boolpush(ElemType ele); 
032    voidclear(); 
033    boolpop(ElemType &ele); 
034    boolempty(); 
035    intcount(); 
036    intGetSize(); 
037}; 
038  
039/* 
040 * 实现环形缓冲区
041 */
042template<typenameElemType> 
043CircleBuffer<ElemType>::CircleBuffer(intMaxSize) : _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<typenameElemType> 
052CircleBuffer<ElemType>::~CircleBuffer()
053{ 
054    delete[]Arr; 
055    Arr = NULL;
056} 
057  
058template<typenameElemType> 
059int CircleBuffer<ElemType>::conv(int i) 
060{ 
061    return(i < _size) ? i : 0; 
062} 
063  
064template<typenameElemType> 
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        returntrue; 
074    } 
075    elsereturn false;
076} 
077  
078template<typenameElemType> 
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        returntrue; 
088    } 
089} 
090  
091template<typenameElemType> 
092int CircleBuffer<ElemType>::count() 
093{ 
094    return_cnt; 
095} 
096  
097template<typenameElemType> 
098bool CircleBuffer<ElemType>::empty() 
099{ 
100    if(!_cnt)return true; 
101    elsereturn false;
102} 
103  
104template<typenameElemType> 
105int CircleBuffer<ElemType>::GetSize() 
106{ 
107    return_size; 
108} 
109  
110template<typenameElemType> 
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<typenameElemType> 
018class CircleBuffer { 
019private:
020    ElemType *Arr;
021    int_l; 
022    int_c; 
023    int_size; 
024    int_cnt; 
025  
026    intconv(int i); 
027public:
028    CircleBuffer(intMaxSize = 65535); 
029    ~CircleBuffer();
030  
031    boolpush(ElemType ele); 
032    voidclear(); 
033    boolpop(ElemType &ele); 
034    boolempty(); 
035    intcount(); 
036    intGetSize(); 
037}; 
038  
039/* 
040 * 实现环形缓冲区
041 */
042template<typenameElemType> 
043CircleBuffer<ElemType>::CircleBuffer(intMaxSize) : _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<typenameElemType> 
052CircleBuffer<ElemType>::~CircleBuffer()
053{ 
054    delete[]Arr; 
055    Arr = NULL;
056} 
057  
058template<typenameElemType> 
059int CircleBuffer<ElemType>::conv(int i) 
060{ 
061    return(i < _size) ? i : 0; 
062} 
063  
064template<typenameElemType> 
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        returntrue; 
074    } 
075    elsereturn false;
076} 
077  
078template<typenameElemType> 
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        returntrue; 
088    } 
089} 
090  
091template<typenameElemType> 
092int CircleBuffer<ElemType>::count() 
093{ 
094    return_cnt; 
095} 
096  
097template<typenameElemType> 
098bool CircleBuffer<ElemType>::empty() 
099{ 
100    if(!_cnt)return true; 
101    elsereturn false;
102} 
103  
104template<typenameElemType> 
105int CircleBuffer<ElemType>::GetSize() 
106{ 
107    return_size; 
108} 
109  
110template<typenameElemType> 
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