在網路通訊中，資料在網路傳輸的格式常以位元組流的形式進行，因此需要我們對位元組流進行寫入和讀出的操作。在幾乎其他所有語言中，網路資料的收發在利用類似send(或write)和recv(或read)的方法時並沒有明顯的流處理。需要藉助流才可以完成。資料流(data stream)是一組有序，有起點和終點的位元組的資料序列。包括輸入流和輸出流。很多語言常將資料流分為輸入流(InputStream)和輸出流(OutputStream)兩類。輸入流只能讀不能寫，而輸出流只能寫不能讀。通常程式中使用輸入流讀出資料，輸出流寫入資料，就好像資料流入到程式並從程式中流出。

為了提高資料的傳輸效率，通常使用緩衝流(Buffered Stream)，即為一個流配有一個緩衝區(buffer)，一個緩衝區就是專門用於傳輸資料的記憶體塊。當向一個緩衝流寫入資料時，系統不直接傳送到外部裝置，而是將資料傳送到緩衝區。緩衝區自動記錄資料，當緩衝區滿時，系統將資料全部傳送到相應的裝置。當從一個緩衝流中讀取資料時，系統實際是從緩衝區中讀取資料。當緩衝區空時，系統就會從相關裝置自動讀取資料，並讀取儘可能多的資料充滿緩衝區。緩衝位元組輸入輸出流，相對於基礎的位元組流有更高的效率，而效率更高的原理在於用空間換取時間。 也就是說使用緩衝流的時候，會先把一定的資料放到緩衝區，也就是記憶體中，然後read的時候直接從緩衝區讀取，這樣就減少了讀寫磁碟檔案的次數，從而減少讀寫時間。

根據上面的原理能否實現位元組流構造器。相容輸入流，輸出流，緩衝流的功能。便於資料的組織和傳輸。同時相容HTTP協議，TCP協議，UDP協議相容的位元組流。程式碼功能越獨立越便於相容。

C++實現網路資料流讀取類：Gk8ByteMaker.h

```c++
//**************************************************************
//@建立者:冰劍
//@功能描述①:網路資料流讀取類:支援指令碼中直接根據模板使用
//@功能描述②:注意伺服器JAVA的高低位問題
//@功能描述③:
//**************************************************************
#ifndef __GK8NETBREADER_H__
#define __GK8NETBREADER_H__

#pragma once
#include "Gk8Env.h"
#include "Gk8PlatformDefine.h"
#include "Gk8BaseObj.h"

class Gk8ByteMaker:public Gk8BaseObj
{
	DECLARE_TOSPP_MAP;	
protected:
	GK8_LPBYTE m_pBuf;		//[資料快取]
	GK8_INT m_nUseSize;		//[使用大小]
	GK8_INT m_nBufSize;		//[快取分配大小]
	GK8_INT m_nReadPos;		//[讀取位置]
public:
	Gk8ByteMaker():m_pBuf(NULL),m_nReadPos(0),m_nUseSize(0),m_nBufSize(0){};
	~Gk8ByteMaker();

static Gk8ByteMaker* Create(Gk8BaseObj* pSuperObj=NULL);

//[屬性操作]
	TOSPP_MEMBER_INT_DECLARE(m_nReadPos,m_nReadPos)
	inline GK8_INT TOSPPFUNC GetStreamSize()const{return m_nUseSize;};

GK8_LPBYTE WriteAlloc(GK8_INT nSize);

//[讀行為操作]
	GK8_BOOL Get(GK8_LPBYTE lpPtr,GK8_INT nLen)const;
	GK8_LPBYTE GetBuf(GK8_INT& nLen);
	inline GK8_LPBYTE GetBuf(){return m_pBuf;};
	inline operator GK8_LPBYTE (){return GetBuf();};

GK8_VOID WriteBuf(GK8_LPCVOID lpPtr,GK8_INT nLen);
	GK8_VOID TOSPPFUNC WriteShort(GK8_INT nData);
	GK8_VOID TOSPPFUNC WriteInt(GK8_INT nData);
	GK8_VOID TOSPPFUNC WriteStr(GK8_LPCSTR lpStr);

//[前面寫入操作]
	GK8_VOID TOSPPFUNC WriteShortAt(GK8_INT nIndex,GK8_INT nData);
	GK8_VOID TOSPPFUNC WriteIntAt(GK8_INT nIndex,GK8_INT nData);
	GK8_VOID TOSPPFUNC WriteStrAt(GK8_INT nIndex,GK8_LPCSTR lpStr);

//[讀取操作]
	GK8_INT TOSPPFUNC ReadShort();
	GK8_INT TOSPPFUNC ReadInt();
	GK8_LPCSTR TOSPPFUNC ReadStr();
	GK8_LONG TOSPPFUNC ReadLong();

//[其它行為操作]
	GK8_VOID ShiftTo(Gk8ByteMaker& iNetBReader);
	inline GK8_VOID SetReadPos(GK8_INT nReadPos){m_nReadPos=nReadPos;};
	inline GK8_VOID TOSPPFUNC ClearStream(){m_nUseSize=0;};
	GK8_VOID Pack();
	GK8_VOID Destroy();
};
#endif
```

C++實現網路資料流讀取類：Gk8ByteMaker.cpp

```c++
#include "Gk8ByteMaker.h"
#include "Gk8MemSpy.h"
#include "Gk8Str.h"
#include "Gk8Helper.h"

/////////////////////////////////////////////CLASS-TOLUA////////////////////////////////////////////////////
TOLUA_CLASS_COLLECT_FUNC(Gk8ByteMaker)

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,Create)
	if(!CheckToLuaFunParam(L,"Create",Gk8Var()<<isusertable return="" gk8baseobj="" psuperobj="NULL;" if="" gk8bytemaker="" pbytemaker="Gk8ByteMaker::Create(pSuperObj);" toluafix_pushusertype_ccobject="" end_tolua_class_func="" begin_tolua_class_func="" tolua_pushnumber="">GetStreamSize());
END_TOLUA_CLASS_FUNC

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,WriteShort)
	if(!CheckToLuaFunParam(L,"WriteShort",Gk8Var()<<isusertype return="" toluagetobj="">WriteShort(TOLUAGETINT(2));
END_TOLUA_CLASS_FUNC

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,WriteInt)
	if(!CheckToLuaFunParam(L,"WriteInt",Gk8Var()<<isusertype return="" toluagetobj="">WriteInt(TOLUAGETINT(2));
END_TOLUA_CLASS_FUNC

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,WriteStr)
	if(!CheckToLuaFunParam(L,"WriteStr",Gk8Var()<<isusertype return="" toluagetobj="">WriteStr(TOLUAGETSTRING(2));
END_TOLUA_CLASS_FUNC

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,WriteShortAt)
	if(!CheckToLuaFunParam(L,"WriteShortAt",Gk8Var()<<isusertype return="" toluagetobj="">WriteShortAt(TOLUAGETINT(2),TOLUAGETINT(3));
END_TOLUA_CLASS_FUNC

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,WriteIntAt)
	if(!CheckToLuaFunParam(L,"WriteIntAt",Gk8Var()<<isusertype return="" toluagetobj="">WriteIntAt(TOLUAGETINT(2),TOLUAGETINT(3));
END_TOLUA_CLASS_FUNC

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,WriteStrAt)
	if(!CheckToLuaFunParam(L,"WriteStrAt",Gk8Var()<<isusertype return="" toluagetobj="">WriteStrAt(TOLUAGETINT(2),TOLUAGETSTRING(3));
END_TOLUA_CLASS_FUNC

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,ReadShort)
	if(!CheckToLuaFunParam(L,"ReadShort",Gk8Var()<<isusertype return="" tolua_pushnumber="">ReadShort());
END_TOLUA_CLASS_FUNC

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,ReadInt)
	if(!CheckToLuaFunParam(L,"ReadInt",Gk8Var()<<isusertype return="" tolua_pushnumber="">ReadInt());
END_TOLUA_CLASS_FUNC

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,ReadStr)
	if(!CheckToLuaFunParam(L,"ReadStr",Gk8Var()<<isusertype return="" tolua_pushstring="">ReadStr());
END_TOLUA_CLASS_FUNC

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,ReadLong)
	if(!CheckToLuaFunParam(L,"ReadLong",Gk8Var()<<isusertype return="" tolua_pushnumber="">ReadLong());
END_TOLUA_CLASS_FUNC

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,SetReadPos)
	if(!CheckToLuaFunParam(L,"SetReadPos",Gk8Var()<<isusertype return="" toluagetobj="">SetReadPos(TOLUAGETINT(2));
END_TOLUA_CLASS_FUNC

BEGIN_TOLUA_CLASS_FUNC(Gk8ByteMaker,ClearStream)
	if(!CheckToLuaFunParam(L,"ClearStream",Gk8Var()<<isusertype return="" toluagetobj="">ClearStream();
END_TOLUA_CLASS_FUNC
//[啟動註冊類的全部TOLUA函式]
BEGIN_TOLUA_FUN_MAP(Gk8ByteMaker)
	TOLUA_CLASS(Gk8ByteMaker,"","[]","[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,Create,"[Gk8ByteMaker* Create(pSuperObj=NULL)?建立物件]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,GetStreamSize,"[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,WriteShort,"[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,WriteInt,"[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,WriteStr,"[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,WriteShortAt,"[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,WriteIntAt,"[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,WriteStrAt,"[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,ReadShort,"[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,ReadInt,"[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,ReadStr,"[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,ReadLong,"[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,SetReadPos,"[]")
	TOLUA_CLASS_FUNC(Gk8ByteMaker,ClearStream,"[]")
END_TOLUA_FUN_MAP

/////////////////////////////////////////////CLASS-TOSPP////////////////////////////////////////////////////
BEGIN_TOSPP_MAP(Gk8ByteMaker,Gk8BaseObj)
	TOSPP_INT(Gk8ByteMaker,m_nReadPos,"m_nReadPos" ,"")
	TOSPP_FUNC(Gk8ByteMaker,GetStreamSize,'d'," ","GetStreamSize()")
	TOSPP_FUNC(Gk8ByteMaker,WriteShort,' ',"d","WriteShort(nData)")
	TOSPP_FUNC(Gk8ByteMaker,WriteInt,' ',"d","WriteInt(nData)")
	TOSPP_FUNC(Gk8ByteMaker,WriteStr,' ',"s","WriteStr(lpStr)")
	TOSPP_FUNC(Gk8ByteMaker,WriteShortAt,' ',"dd","WriteShortAt(nIndex,nData)")
	TOSPP_FUNC(Gk8ByteMaker,WriteIntAt,' ',"dd","WriteIntAt(nIndex,nData)")
	TOSPP_FUNC(Gk8ByteMaker,WriteStrAt,' ',"ds","WriteStrAt(nIndex,lpStr)")
	TOSPP_FUNC(Gk8ByteMaker,ReadShort,'d'," ","ReadShort()")
	TOSPP_FUNC(Gk8ByteMaker,ReadInt,'d'," ","ReadInt()")
	TOSPP_FUNC(Gk8ByteMaker,ReadStr,'s'," ","ReadStr()")
	TOSPP_FUNC(Gk8ByteMaker,ReadLong,'P'," ","ReadLong()")
	TOSPP_FUNC(Gk8ByteMaker,ClearStream,' '," ","ClearStream()")
END_TOSPP_MAP()

///////////////////////////[網路二進位制讀取邏輯]///////////////////
Gk8ByteMaker::~Gk8ByteMaker()
{
	if(m_pBuf) _Gk8Free(m_pBuf);
}
Gk8ByteMaker* Gk8ByteMaker::Create(Gk8BaseObj* pSuperObj)
{
	Gk8ByteMaker* pByteMaker=new Gk8ByteMaker();
	if(pSuperObj) pByteMaker->SetSuper(pSuperObj);
	return pByteMaker;
}

TOSPP_MEMBER_INT_FUN(Gk8ByteMaker,m_nReadPos,m_nReadPos)
//[提前增加指定長度的記憶體塊]
GK8_LPBYTE Gk8ByteMaker::WriteAlloc(GK8_INT nSize)
{
	if(nSize>=1)
	{
		if(nSize+m_nUseSize>=m_nBufSize)
		{
			GK8_UINT nNewSize;
			m_pBuf=(GK8_LPBYTE)_Gk8ReAlloc(m_pBuf,m_nUseSize+nSize+32,nNewSize);
			m_nBufSize=nNewSize;
		}
		m_nUseSize+=nSize;
		return m_pBuf+m_nUseSize-nSize;
	}
	return NULL;
}

//[獲取指定長度的二進位制資料]
GK8_BOOL Gk8ByteMaker::Get(GK8_LPBYTE lpPtr,GK8_INT nLen)const
{
	if(m_nUseSize>=nLen) memcpy(lpPtr,m_pBuf,nLen);
	return true;
}
//[獲取資料的記憶體指標]
GK8_LPBYTE Gk8ByteMaker::GetBuf(GK8_INT& nLen)
{
	nLen=m_nUseSize;
	return m_pBuf;
}

//[增加指定長度的二進位制資料]
GK8_VOID Gk8ByteMaker::WriteBuf(GK8_LPCVOID lpPtr,GK8_INT nLen)
{
	GK8_LPBYTE pMem=WriteAlloc(nLen);
	memcpy(pMem,lpPtr,nLen);
}

GK8_VOID Gk8ByteMaker::WriteShort(GK8_INT nData)
{
	GK8_LPBYTE pMem=WriteAlloc(sizeof(GK8_WORD));
	GK8_LPBYTE pDataMem=(GK8_LPBYTE)&nData;
	pMem[0]=pDataMem[1];
	pMem[1]=pDataMem[0];
}

GK8_VOID Gk8ByteMaker::WriteInt(GK8_INT nData)
{
	GK8_LPBYTE pMem=WriteAlloc(sizeof(GK8_INT));
	GK8_LPBYTE pDataMem=(GK8_LPBYTE)&nData;
	pMem[0]=pDataMem[3];
	pMem[1]=pDataMem[2];
	pMem[2]=pDataMem[1];
	pMem[3]=pDataMem[0];
}

GK8_VOID Gk8ByteMaker::WriteStr(GK8_LPCSTR lpStr)
{
	Gk8Str iStr=lpStr;
	WriteShort(iStr.GetLength());
	WriteBuf(iStr,iStr.GetLength());
}

GK8_VOID Gk8ByteMaker::WriteShortAt(GK8_INT nIndex,GK8_INT nData)
{
	GK8_INT nLen=sizeof(GK8_WORD);
	WriteAlloc(nLen);
	memmove(m_pBuf+nIndex+nLen,m_pBuf+nIndex,m_nUseSize-nLen-nIndex);
	GK8_LPBYTE pDataMem=(GK8_LPBYTE)&nData;
	m_pBuf[nIndex]=pDataMem[1];
	m_pBuf[nIndex+1]=pDataMem[0];
}

GK8_VOID Gk8ByteMaker::WriteIntAt(GK8_INT nIndex,GK8_INT nData)
{
	GK8_INT nLen=sizeof(GK8_INT);
	WriteAlloc(nLen);
	memmove(m_pBuf+nIndex+nLen,m_pBuf+nIndex,m_nUseSize-nLen-nIndex);

GK8_LPBYTE pDataMem=(GK8_LPBYTE)&nData;
	m_pBuf[nIndex]=pDataMem[3];
	m_pBuf[nIndex+1]=pDataMem[2];
	m_pBuf[nIndex+2]=pDataMem[1];
	m_pBuf[nIndex+3]=pDataMem[0];
}

GK8_VOID Gk8ByteMaker::WriteStrAt(GK8_INT nIndex,GK8_LPCSTR lpStr)
{
	Gk8Str iStr=lpStr;
	GK8_INT nStrLen=iStr.GetLength();
	GK8_INT nLen=sizeof(GK8_WORD)+nStrLen;
	WriteAlloc(nLen);
	memmove(m_pBuf+nIndex+nLen,m_pBuf+nIndex,m_nUseSize-nLen-nIndex);
	GK8_LPBYTE pDataMem=(GK8_LPBYTE)&nStrLen;
	m_pBuf[nIndex]=pDataMem[1];
	m_pBuf[nIndex+1]=pDataMem[0];
	memcpy(m_pBuf+nIndex+sizeof(GK8_WORD),iStr,nStrLen);
}

GK8_INT Gk8ByteMaker::ReadShort()
{
	if(m_nReadPos>m_nUseSize-sizeof(GK8_WORD)) return NULL;
	GK8_INT nData;
	GK8_LPBYTE pDataMem=(GK8_LPBYTE)&nData;
	memset(pDataMem,0,sizeof(GK8_INT));
	pDataMem[1]=m_pBuf[m_nReadPos];
	pDataMem[0]=m_pBuf[m_nReadPos+1];
	m_nReadPos+=sizeof(GK8_WORD);
	return nData;
}

GK8_INT Gk8ByteMaker::ReadInt()
{
	if(m_nReadPos>m_nUseSize-sizeof(GK8_INT)) return 0;
	GK8_INT nData;
	GK8_LPBYTE pDataMem=(GK8_LPBYTE)&nData;
	memset(pDataMem,0,sizeof(GK8_INT));
	pDataMem[3]=m_pBuf[m_nReadPos];
	pDataMem[2]=m_pBuf[m_nReadPos+1];
	pDataMem[1]=m_pBuf[m_nReadPos+2];
	pDataMem[0]=m_pBuf[m_nReadPos+3];
	m_nReadPos+=sizeof(GK8_INT);
	return nData;
}

GK8_LPCSTR Gk8ByteMaker::ReadStr()
{
	if(m_nReadPos>m_nUseSize-sizeof(GK8_WORD)) return NULL;
	GK8_INT nLen;
	GK8_LPBYTE pDataMem=(GK8_LPBYTE)&nLen;
	memset(pDataMem,0,sizeof(GK8_INT));
	pDataMem[1]=m_pBuf[m_nReadPos];
	pDataMem[0]=m_pBuf[m_nReadPos+1];
	m_nReadPos+=sizeof(GK8_WORD);
	Gk8Str iStr;
	iStr.SetStr((GK8_LPCSTR)(m_pBuf+m_nReadPos),nLen);
	m_nReadPos+=nLen;
	return iStr;
}

GK8_LONG Gk8ByteMaker::ReadLong()
{
	return 0;
}
//[克隆到另外一個實體中]
GK8_VOID Gk8ByteMaker::ShiftTo(Gk8ByteMaker& iBReader)
{
	iBReader.Destroy();
	iBReader.m_pBuf=m_pBuf;
	iBReader.m_nUseSize=m_nUseSize;
	iBReader.m_nBufSize=m_nBufSize;
	iBReader.m_nReadPos=m_nReadPos;
	m_pBuf=NULL;
	m_nBufSize=0;
	m_nUseSize=0;
	m_nReadPos=0;
}
//[整理資料:前面有記憶體已讀取後面空餘前移動]
GK8_VOID Gk8ByteMaker::Pack()
{
	if(m_nReadPos==m_nUseSize)
	{
		m_nUseSize=0;
		m_nReadPos=0;
		return;
	}
	memmove(m_pBuf,m_pBuf+m_nReadPos,m_nUseSize-m_nReadPos);
	m_nUseSize-=m_nReadPos;
	m_nReadPos=0;
}
//[銷燬]
GK8_VOID Gk8ByteMaker::Destroy()
{
	if(m_pBuf) _Gk8Free(m_pBuf);
	m_pBuf=NULL;
	m_nUseSize=0;
	m_nBufSize=0;
	m_nReadPos=0;
}
```</isusertype></isusertype></isusertype></isusertype></isusertype></isusertype></isusertype></isusertype></isusertype></isusertype></isusertype></isusertype></isusertable>

網路通訊1：位元組流的封裝

相關文章