環形緩沖區類(C++)絕對可用(轉)

參考網絡循環緩沖區類源碼，修改了作者的兩個bug，經測試，可以實現多線程並發讀寫。數據准確無誤。

多線程並行讀寫環形緩沖區源代碼例子

代碼例子下載：環形緩沖區VC+Qt的項目代碼

理論如下：

源碼如下：

CCycleBuffer.h

//環形緩沖區頭文件

#ifndef CCycleBuffer_H
#define CCycleBuffer_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);
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;
int test;
};
#endif// CCycleBuffer_H

 

 

CCycleBuffer.c

//環形緩沖區源文件
//盡量用C運行時庫代碼，改變了原作者基於WindowsAPI的代碼。
//修改了原作者的兩處錯誤，1是read函數最后的else 少了一個leftcount
//第二個錯誤，是write函數中，m_nWritePos 變量，他重新定義了一個。這些錯誤編譯不會出錯。
//但是運行起來，要了親命啊。

#include "CCycleBuffer.h"
#include <assert.h>
#include <memory.h>
#include <QDebug>
// 定義  
CCycleBuffer::CCycleBuffer(int size)

{
m_nBufSize = size;  
m_nReadPos =0;  
m_nWritePos =0;  
m_pBuf =newchar[m_nBufSize];
m_bEmpty =true;  
m_bFull =false;
test =0;
}  
CCycleBuffer::~CCycleBuffer()  
{  
delete[] m_pBuf;  
}  
/************************************************************************/  
/* 向緩沖區寫入數據，返回實際寫入的字節數                               */  
/************************************************************************/  
int CCycleBuffer::write(char* buf,int count)  
{  
if(count <=0)
  return0;  
m_bEmpty =false;  
// 緩沖區已滿，不能繼續寫入  
if(m_bFull)   
{  
  return0;  
}  
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;
  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  
{  
  /*                          == 內存模型 == 
   (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)
  return0;  
m_bFull =false;  
if(m_bEmpty)       // 緩沖區空，不能繼續讀取數據  
{  
  return0;  
}  
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 + 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)  
{  
  return0;  
}  
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;  
}  

 

 

原帖地址：http://blog.163.com/qimo601@126/blog/static/1582209320121169244219/