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

讀寫鎖版本（推薦）：https://blog.csdn.net/yunandsha/article/details/80925429

參考網絡循環緩衝區類源碼，修改了作者的兩個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;
}

原帖地址：https://blog.csdn.net/devday/article/details/5258697