C++环状队列（数据缓冲区）

头文件：

#include <mutex>
#include <atomic>
class CBuffer
{
public:
	CBuffer();//缓存一百万数据
	~CBuffer();
	void Init();//初始化
	void Reset();//重置标志位
	bool Write(char*buf, int len);
	bool Read(char*buf, int len);

private:
	std::atomic_int w_index;//写指针
	std::atomic_int r_index;//读指针
	std::atomic_int totalen;//总数据长度
	std::atomic_char*m_data;//缓冲区
	std::mutex _mutex;//互斥锁

};

.cpp

#include "Buffer.h"
#define BUFFSIZE 5242880 //1024*1024*5 缓冲区大小设为5M

CBuffer::CBuffer()
{
	m_data = NULL;
}

CBuffer::~CBuffer()
{
	if (m_data) delete[] m_data;
}

void CBuffer::Init()
{
	if (m_data != NULL)
		return;

	m_data = new std::atomic_char[BUFFSIZE];//默认缓冲区大小1024*1024

	w_index = 0;//写指针
	r_index = 0;//读指针
	return;
}

void CBuffer::Reset()//重置标志位
{
	w_index = 0;//写指针
	r_index = 0;//读指针
	return;
}

//写数据
bool CBuffer::Write(char*buf, int len)
{
	int curlen = (w_index +1 + BUFFSIZE - r_index) % BUFFSIZE;//当前缓冲区数据长度
	if ((curlen + len) > BUFFSIZE) //缓冲区剩余长度无法存放写入数据 
	{
		return false;
	}

	std::lock_guard<std::mutex>guard(_mutex);
	if ((w_index + len) > BUFFSIZE)// 写指针溢出
	{
		int overlen = w_index + len - BUFFSIZE;  //超出长度部分
		int loadlen = len - overlen;			 //可负载长度
		memcpy(m_data + w_index, buf, loadlen);	 //写入可负载数据

		memcpy(m_data, buf + loadlen, overlen);	 //从头写入超出部分
		w_index = (w_index + len) % BUFFSIZE;	//取余 写指针位置
	}
	else//长度不超出
	{
		memcpy(m_data + w_index, buf, len);//写入缓冲区
		w_index += len;
	}
	return true;
}

//读数据
bool CBuffer::Read(char*buf, int len)
{
	int curlen = (w_index +1 + BUFFSIZE - r_index) % BUFFSIZE;//当前缓冲区数据长度
	if (curlen < len)//缓冲区数据不足以读取
	{
		return false;
	}
	std::lock_guard<std::mutex>guard(_mutex);
	if ((r_index + len) > BUFFSIZE)//读取溢出
	{
		int overlen = r_index + len - BUFFSIZE;	//超出部分长度
		int loadlen = len - overlen;			//可用长度
		memcpy(buf, m_data + r_index, loadlen);
		memcpy(buf + loadlen, m_data, overlen);
		r_index = (r_index + len) % BUFFSIZE;	//取余 读指针位置
	}
	else//长度不超出
	{
		memcpy(buf, m_data + r_index, len);
		r_index += len;
	}
	return true;
}