环缓冲托管实现

最新推荐文章于 2024-09-21 10:08:32 发布

趴在树上写代码的猫

最新推荐文章于 2024-09-21 10:08:32 发布

阅读量480

点赞数

分类专栏： C/C++ 文章标签： C++ 记录

本文链接：https://blog.csdn.net/kinly_jiang/article/details/50372783

版权

C/C++ 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

// 这个缓冲将被用作ring_buffer测试
class x_buffer
{
private:
	#pragma pack(1)
	typedef struct {
		volatile size_t _rd;
		volatile size_t _wd;
		volatile size_t _size;
		volatile bool   _empty;
		char _data[1];
	}x_buffer_data, *x_buffer_data_ptr;	

	x_buffer_data_ptr _buffer_data;
public:
	x_buffer()
		:_buffer_data(nullptr)
	{}
	x_buffer(size_t size)
	{
		_buffer_data = (x_buffer_data_ptr)( new char(size + sizeof(x_buffer_data)) );
		_buffer_data->_size = size;
		_buffer_data._rd = _buffer_data._wd = 0;
		_buffer_data._empty = true;
		memset(_buffer_data->_data, 0, _buffer_data->_size);
	}
	char* base(){return _buffer_data._data;}
	const char* base(){return _buffer_data._data;}
	size_t capacity(){return _buffer_data._size();}
	size_t rd(){return _buffer_data._rd;}
	char* rd_ptr(){return base() + _buffer_data._rd;}
	void set_rd(size_t rd_){_buffer_data._rd = rd_;}
	size_t wd(){return _buffer_data._wd;}
	char* wd_ptr(){return base() + _buffer_data._wd;}
	void set_wd(size_t wd_){_buffer_data._wd = wd_;}
	bool empty(){return _buffer_data._empty;}
	void set_empty(bool empty_){_buffer_data._empty = empty_;}
};

// ring托管类
template<class _Buffer>
class ring_buffer
{
private:
	_Buffer _buffer;

public:
	ring_buffer(){}
	ring_buffer(const _Buffer& buffer):_buffer(buffer){}
	~ring_buffer(){}
	void assign(_Buffer&& buffer){_buffer = std::forward<_Buffer>(buffer);}

	// 写入内容
	size_t write(const char* value, size_t len)
	{
		if (_buffer.wd() == _buffer.rd() && !_buffer.empty())
			return -1;
		if (_buffer.wd() > _buffer.rd() 
			&& _buffer.capacity() + 1 - _buffer.wd() < len 
			&& _buffer.capacity() + 1 - _buffer.wd() + _buffer.rd() <= len)
			return -1;
		else if (_buffer.wd() < _buffer.rd() && _buffer.rd() <= _buffer.wd() + len)
			return -1;

		if (_buffer.capacity() >= _buffer.wd() + len)
		{
			memcpy(_buffer.wd_ptr(), value, len);
			_buffer.set_wd(_buffer.wd() + len);
		}
		else
		{
			size_t sublen = _buffer.capacity() - _buffer.wd();
			memcpy(_buffer.wd_ptr(), value, sublen);
			memcpy(_buffer.base(), value + sublen, len - sublen);
			_Buffer.set_wd(len - sublen);
		}
		if (_buffer.wd() == _buffer.rd())
			_buffer.set_empty(false);
		return len;
	}
	size_t write(const char* value)
	{
		return write(value, strlen(value));
	}
	// 读取指定长度
	size_t read(const char* value, size_t len)
	{
		if (_buffer.wd() == _buffer.rd() && _buffer.empty())
			return -1;
		else if (_buffer.wd() > _buffer.rd() && _buffer.wd() < len + _buffer.rd())
			return -1;
		else if (_buffer.capacity() - _buffer.rd() < len && _buffer.wd() + (_buffer.capacity() - _buffer.rd()) < len)
			return -1;

		if (_buffer.capacity() >= _buffer.rd() + len)
		{
			memcpy(value, _buffer.rd_ptr(), len);
			_buffer.set_rd(_buffer.rd() + len);
		}
		else
		{
			size_t sublen = _buffer.capacity() - _buffer.rd();
			memcpy(value, _buffer.rd_ptr(), sublen);
			memcpy(value + sublen, _buffer.base(), len - sublen);
			_buffer.set_rd(len - sublen);
		}
		if (_buffer.wd() == _buffer.rd())
			_buffer.set_empty(true);
		return len;
	}
	// 读取全部
	size_t read(const char* value)
	{
		if (_buffer.wd() == _buffer.rd() && _buffer.empty())
			return -1;

		size_t len = 0;
		if (_buffer.wd() > _buffer.rd())
		{
			memcpy(value, _buffer.rd_ptr(), _buffer.wd() - _buffer.rd());
			len = _buffer.wd() - _buffer.rd();
		}
		else
		{
			size_t sublen = _buffer.capacity() - _buffer.rd();
			memcpy(value, _buffer.rd_ptr(), sublen);
			memcpy(value + sublen, _buffer.base(), _buffer.wd());
			len = sublen + _buffer.wd();
		}
		_buffer.set_rd(_buffer.wd());
		_buffer.set_empty(true);
		return len;
	}
};

解释：期望实现一个环形缓冲托管方法，可以托管任何buffer（主要用作共享内存，所以类型用了char）

除了托管上面的测试buff，还可以用在一些static_buffer上面。譬如：template<size_t size>class static_buffer{char _data[size];.....}。

规定了被托管对象一定要有的一些函数成员。