c++ 网络套接字缓冲区ByteBuf封装

基于socket的通信必然会操作字节流，一直用netty（mina）的buf，挺方便的，前段时间写cocos2dx，就自己封装了一个c++版本 ：

#ifndef __CCNET_BYTEBUF_H__
#define __CCNET_BYTEBUF_H__

#include <stdlib.h>
#include <vector>
using namespace std;
 
/************************************************************************/
/* 构建发送数据buffer，封装读/写                                                                     */
/************************************************************************/
class ByteBuf
{
public:
     
    ByteBuf();
	ByteBuf(int capacity);

    ~ByteBuf(void);
public:
    void writeShort(short value);
	void writeInt(int value);
    void writeByte(char ch);
	void wirteBytes(char *str);
	void wirteBytes(char*str, int srcIndex, int length);
	void wirteBytes(ByteBuf *buffer);
	void wirteBytes(ByteBuf *buffer, int length);
	void wirteBytes(ByteBuf *buffer, int srcIndex, int length);

    ///写入一个字符串，先写4字节长度，再写字符串
    void writeString(const char* str);
    //写入一个字符串
	void writeString(const char*str,int length);
	//
	int writeIndex();
	//返回写入的数据
    char* flush();
    //释放buffer
    void release();
public:
    ///read a int  4
    int readInt();
    ///read a short	  2
    short readShort();
    ///read a char   1
    char readByte();
	//don't deleted this point ,only last call release methed
	char* readString();
	 //don't deleted this point ,only last call release methed
	char* readString(int length);

	char* readString(int srcIndex,int length);

	//return writeindex-readindex
	int readableBytes();
	 //
	int readIndex();

private:
	void checkRead(int length);
private:
    ///will be handed  data
    char* data;
	//readIndex
    int _readIndex;
	// writeIndex
	int _writeIndex;
    ///缓冲的待处理字节数
    vector<char> cache_data;
    ///待释放的字符串
    vector<char*> release_and_delete;
};
#endif

#include "stdafx.h"
#include "ByteBuf.h"

//stream动态缓冲区的初始化大小
#define BYTE_BUFFER_SIZE 512
ByteBuf::~ByteBuf(){}

ByteBuf::ByteBuf(){
    this->data = NULL;
    this->_readIndex = 0;
	this->_writeIndex = 0;
    this->cache_data.reserve(BYTE_BUFFER_SIZE);	   // 预分配空间
}
ByteBuf::ByteBuf(int capacity)
{
	this->data = NULL;
	this->_readIndex = 0;
	this->_writeIndex = 0;
	this->cache_data.reserve(BYTE_BUFFER_SIZE);
}


char*ByteBuf::flush(){
    int _size = this->readableBytes();
	if (_size != 0)
    {
        int nIdx = 0;
		this->data = new char[_size];
        for(auto iter = cache_data.begin(); iter != cache_data.end(); iter++, nIdx++)
        {
            this->data[nIdx] = *iter;
        }
        return this->data;		   //this data will be  dispatcher by logic		, be careful    at last you must be call release
    }
    return NULL;
}


void ByteBuf::release(){
	if (data != NULL)
	{
		delete data;
	}
	data = nullptr;
	this->_readIndex = 0;
	this->_writeIndex = 0;
	cache_data.clear();

	if (!release_and_delete.empty())
	{
		for (auto iter = begin(release_and_delete); iter != end(release_and_delete); ++iter)
		{
			delete *iter;
			*iter = nullptr;
		}
	}
	release_and_delete.clear();
}
 

void ByteBuf::writeShort(short num)
{
    this->cache_data.push_back( ((0xff00 & num) >> 8) );
    this->cache_data.push_back( (0xff & num) );
	_writeIndex += 0x2;
}
 

void ByteBuf::writeInt(int num)
{
    this->cache_data.push_back( ((0xff000000 & num) >> 24) );
    this->cache_data.push_back( ((0xff0000 & num) >> 16) );
    this->cache_data.push_back( ((0xff00 & num) >> 8) );
    this->cache_data.push_back( (0xff & num) );
	_writeIndex += 0x4;
}
 

void ByteBuf::writeByte(char ch)
{
    this->cache_data.push_back(ch);
	_writeIndex += 0x1;
}

void ByteBuf::wirteBytes(char *str)
{
	wirteBytes(str, 0, strlen(str));
}

void ByteBuf::wirteBytes(char*str, int srcIndex, int length)
{
	for (int index = srcIndex; index != length;++index)
		   {
		this->cache_data.push_back(str[index]);
		   }
	_writeIndex += length;
}

void ByteBuf::wirteBytes(ByteBuf *buffer)
{
	wirteBytes(buffer, buffer->_writeIndex);
	buffer->release();
}

void ByteBuf::wirteBytes(ByteBuf *buffer, int length)
{
	wirteBytes(buffer,0,buffer->_writeIndex);
	buffer->release();
}

void ByteBuf::wirteBytes(ByteBuf *buffer, int srcIndex, int length)
{
	for (int index = srcIndex; index != length;++index)
	{
		this->cache_data.push_back(buffer->cache_data[index]);
	}
	_writeIndex += length;
	buffer->release();
}

void ByteBuf::writeString(const char* str)
{
	auto _size = strlen(str);
	for (int index = 0; index != _size; ++index){
		this->cache_data.push_back(str[index]);
	}
	_writeIndex += _size;
}

void ByteBuf::writeString(const char*str, int length)
{
	for (int index = 0; index != length; ++index){
		this->cache_data.push_back(str[index]);
	}
	_writeIndex += length;
}

int ByteBuf::writeIndex(){
	return this->_writeIndex;
}


int ByteBuf::readIndex()
{
	return _readIndex;
}

int ByteBuf::readInt()
{
	checkRead(4);
	int addr = cache_data[_readIndex + 3] & 0xff;
	addr |= ((cache_data[_readIndex + 2] << 8) & 0xff00);
	addr |= ((cache_data[_readIndex + 1] << 16) & 0xff0000);
	addr |= ((cache_data[_readIndex] << 24) & 0xff000000);
	_readIndex += 4;
	return addr;
    return 0;
}
 

short ByteBuf::readShort()
{
	checkRead(2);
	short addr = cache_data[_readIndex + 1] & 0xff;
	addr |= ((cache_data[_readIndex] << 8) & 0xff00);
	_readIndex += 2;
	return addr;
}
 
char ByteBuf::readByte()
{
	checkRead(1);
	char addr = cache_data[_readIndex];
	_readIndex += 1;
	return addr;
    return 0;
}
 
char* ByteBuf::readString()
{
	return readString(_writeIndex);
}
char* ByteBuf::readString(int length)
{
	if (length <= 0)return nullptr;
	char * temp = new char[length];
	for (int index = 0; index != length; ++index)
	{
		temp[index] = this->cache_data[_readIndex];
		++_readIndex;
	}
	release_and_delete.push_back(temp);
	return temp;
}

char* ByteBuf::readString(int srcIndex, int length)
{
	if (length <= 0)return nullptr;

	char * temp = new char[length];
	for (int index = 0; index != length ; ++index)
	{
		temp[index] = this->cache_data[srcIndex];	 //指定位置开始读取数据
		++srcIndex;
	}
	_readIndex += length;
	release_and_delete.push_back(temp);
	return temp;
}

int ByteBuf::readableBytes()
{
	auto _size = _writeIndex - _readIndex;
	return _size < 0 ? 0 : _size;
}

void ByteBuf::checkRead(int length)
{
			  if (_writeIndex<length)
			  {
				  throw std::exception("_writeIndex less can read length!");
			  }
}