环形缓冲区设计

流的处理很多地方都用到了环形缓冲区，其实就是开辟的一段内存区域，重复使用，有流经过时，就写入

里边，当前的写入点，可以是缓冲区中的任意一点，当然，此时读入点和写入点重合的话，表明此时的

缓冲区已被占满，流的尺寸太大。

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);
int getStart()
{
return m_nReadPos;
}
int getEnd()
{
return m_nWritePos;
}
 
private:
bool m_bEmpty, m_bFull;
char* m_pBuf;
int m_nBufSize;
int m_nReadPos;
int m_nWritePos;
};

#include "CCycleBuffer.h"
#include <assert.h>
#include <memory.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)// 缓冲区为空时 
{ 

  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)// 有剩余空间可写入 
{ 
 
  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 
{ 
  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)   // 缓冲区满时 
{ 
  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)   // 写指针在前(未读数据是连接的) 
{ 

  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          // 读指针在前(未读数据可能是不连接的) 
{ 
 
  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) 
{ 
  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; 
}