如何用建立一个缓冲不断收数据不断的填充buf直到接收的数据不为零！

Question

如何用建立一个缓冲不断收数据不断的填充buf直到接收的数据不为零

Answer 1

我用CByteArray 开启了一个buf，我只能拷贝一次数据，后面的数据就没有办法拷贝，我想把后面的数据和前面额达数据一起填充写成文件，知道传来的数据为零。

Answer 2

为什么不直接用个char来操作
char * buf = new char[bufsize];
char * pbuf = buf;memcpy(pbuf,srcbuf,strlen);
pbuf += strlen;
.........
.........
delete [] buf;

Answer 3

int nLen = 0;
int nBytesRecv;
char szRecv[1024]; //缓冲大小自定义或者new也可以while(nLen < sizeof(szRecvBuf))
{
nBytesRecv = recv(m_sockData, szRecvBuf + nLen, sizeof(szRecvBuf) - nLen, 0);
nLen += nBytes;
}

Answer 4

int nLen = 0;
int nBytesRecv;
char szRecv[1024]; //缓冲大小自定义或者new也可以while(nLen < sizeof(szRecvBuf))
{
nBytesRecv = recv(m_sockData, szRecvBuf + nLen, sizeof(szRecvBuf) - nLen, 0);
nLen += nBytesRecv; //这里上面的打错了
}

Answer 5

#define IOBUFFLEN 8196*10
class CSimpleIOBuffer    
{
public:
void SetTotalSize(DWORD _size);
void Notify();
void Reset();
DWORD GetBufferLen();
BOOL Read(char * _buff,DWORD _len);
BOOL Write(char * _buff,DWORD _len);
CSimpleIOBuffer();
virtual ~CSimpleIOBuffer();
protected:
BYTE *buff;
DWORD start,end;
CRITICAL_SECTION m_cs;//for one frame
private:
DWORD m_bufferLenTotal;

};

Answer 6

CSimpleIOBuffer::CSimpleIOBuffer() 
{ 
m_bufferLenTotal = IOBUFFLEN;
InitializeCriticalSection(&m_cs); buff = new BYTE[m_bufferLenTotal];
Reset();
}CSimpleIOBuffer::~CSimpleIOBuffer()
{
delete []buff;
buff = NULL;
DeleteCriticalSection(&m_cs);

}BOOL CSimpleIOBuffer::Write(char *_buff, DWORD _len)
{
CLock(m_cs,"CSimpleIOBuffer::Write");
if(GetBufferLen() + _len > m_bufferLenTotal)
{
TRACE("buffer is full,erro!\n");
return FALSE;
}
if(end + _len > m_bufferLenTotal)
{
memcpy(buff + end,_buff,m_bufferLenTotal - end - 1);
memcpy(buff,_buff + (m_bufferLenTotal - end - 1),_len - m_bufferLenTotal + end + 1);
end = _len - m_bufferLenTotal + end + 1;
}else
{
memcpy(buff + end,_buff,_len);
end = end + _len;
}
TRACE("CSimpleIOBuffer Write points start:%u end:%u\n",start,end);
return TRUE;

}BOOL CSimpleIOBuffer::Read(char *_buff, DWORD _len)
{
CLock(m_cs,"CSimpleIOBuffer::Read");
if(GetBufferLen() < _len)
{
TRACE(_T("buffer is less than read,erro! Realbuff:%d-ReadLen:%d!\n"),GetBufferLen(),_len);
return FALSE;
} if(start + _len > m_bufferLenTotal)
{
memcpy(_buff ,buff+ start,m_bufferLenTotal - start - 1);
memcpy(_buff + m_bufferLenTotal - start - 1,buff ,_len - m_bufferLenTotal + start + 1);
start = _len - m_bufferLenTotal + start + 1; }else
{
memcpy(_buff,buff + start,_len);
start = start + _len;
}
TRACE("CSimpleIOBuffer Read points start:%u end:%u\n",start,end);
return TRUE;}DWORD CSimpleIOBuffer::GetBufferLen()
{
CLock(m_cs,"CSimpleIOBuffer::GetBufferLen");
if(end < start)
return end + m_bufferLenTotal - start;
else
return end - start;
}void CSimpleIOBuffer::Reset()
{
CLock(m_cs,"CSimpleIOBuffer::Reset");
start = 0;
end = 0;
memset(buff,0,m_bufferLenTotal);

}void CSimpleIOBuffer::Notify()
{
CLock(m_cs,"CSimpleIOBuffer::Notify");
if(start == end)
{
Reset();
}
}void CSimpleIOBuffer::SetTotalSize(DWORD _size)
{
CLock(m_cs,"CSimpleIOBuffer::SetTotalSize");
ASSERT( _size > 1024);
m_bufferLenTotal = _size;
delete []buff;
buff = new BYTE [m_bufferLenTotal];
Reset();
}

Answer 7

char m_bBuffer[MAX_BUFFER_LEN ];
     memset(m_bBuffer,0,sizeof(m_bBuffer));
int nRead;
int idex=0,nLen=0;
while( idex < MAX_BUFFER_LEN )
{
nRead=recv(m_hConnectSocket,&m_bBuffer[idex],MAX_BUFFER_LEN - idex,0);
if(nRead==SOCKET_ERROR||nRead==0||nRead==WSAEWOULDBLOCK)
{
break;
}
idex +=nRead;
nLen +=nRead;
}
看一下效果！

Answer 8

用Stl的deque
双向数组 感觉不错