C++ 循环缓冲类

昨天看到博客园有个面试者笔试出现此题，昨天大概给出思路，今天经过思考将实现，并做出优化改进 ，逻辑易懂，基本都可以看懂，经过初步测试正确。代码如下：

// MindryBuffer.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <string.h>
using namespace std;

class CMindryBuffer
{
public:
    CMindryBuffer(int iBufLenth = MindryBufferLenth);
    ~CMindryBuffer(void);

    int  ReSize(int iBufLenth);                        //重置缓冲区大小
    int     Read(char * pData,int iReadDataLength);    //读取指定数据
    int  Write(char * pData,int iWriteDataLength);    //写入指定数据

    void Clear();                                    //清空缓冲区
    int     GetCapicity();                                //获取缓冲区容量
    int     GetWriteAvailable();                        //缓冲区可写数据  可通过此函数判断缓冲区是否已满
    int     GetReadAvailable();                         //缓冲区可读数据  可通过此函数判断缓冲区是否为空    

private:
    const static int MindryBufferLenth = 10;        //默认缓冲区长度
    int m_iBufLenth;                                //缓冲区
    int m_iWritePos;                                //写入起始位置
    int m_iReadPos;                                    //读取起始位置
    int m_iDataLenth;                                //缓冲区存放数据长度
    char *m_PData;                                    //缓冲区数据指针
};

CMindryBuffer::CMindryBuffer(int iBufLenth)
{    
    m_PData = NULL;
    m_iWritePos = 0;
    m_iReadPos = 0;
    m_iDataLenth = 0;
    m_iBufLenth = iBufLenth;
    if (m_iBufLenth > 0)
    {
        m_PData = new char[m_iBufLenth];
    }
}

CMindryBuffer::~CMindryBuffer(void)
{
    if (m_PData) 
    {
        delete [] m_PData;
    }
}


int  CMindryBuffer::Write(char * pData,int iWriteDataLength)
{
    if (m_iBufLenth - m_iDataLenth == 0 || !m_PData )    
    {
        return 0;
    }

    int iCanWriteDataLength =  iWriteDataLength> GetWriteAvailable()? GetWriteAvailable():iWriteDataLength;

    int iNowWriteToEndLength = m_iBufLenth - m_iWritePos;
    if (iNowWriteToEndLength >= iCanWriteDataLength)
    {
        memcpy(&m_PData[m_iWritePos],pData,iCanWriteDataLength);
        m_iWritePos += iCanWriteDataLength;
    }
    else
    {
        memcpy(&m_PData[m_iWritePos],pData,iNowWriteToEndLength);
        memcpy(m_PData,&pData[iNowWriteToEndLength],iCanWriteDataLength - iNowWriteToEndLength);        
        m_iWritePos = iCanWriteDataLength - iCanWriteDataLength;
    }
    m_iDataLenth += iCanWriteDataLength;
    return iCanWriteDataLength;
}

int     CMindryBuffer::Read(char * pData,int iReadDataLength)
{
    if (m_iDataLenth == 0) 
    {
        return 0;
    }
    int iCanReadDataLength = iReadDataLength>m_iDataLenth? m_iDataLenth:iReadDataLength;
    int iNowReadToEndLength = m_iBufLenth - m_iReadPos;

    if (iNowReadToEndLength >= iCanReadDataLength)
    {
        memcpy(pData,&m_PData[m_iReadPos],iCanReadDataLength);
        m_iReadPos += iCanReadDataLength;
    }
    else
    {
        memcpy(pData,&m_PData[m_iReadPos],iNowReadToEndLength);
        memcpy(&pData[iNowReadToEndLength],m_PData,iCanReadDataLength - iNowReadToEndLength);    

        m_iReadPos = iCanReadDataLength - iNowReadToEndLength;
    }
    m_iDataLenth -= iCanReadDataLength;
    return iCanReadDataLength;
}

int  CMindryBuffer::ReSize(int iBufLenth)
{
    if (iBufLenth > m_iBufLenth )
    {    
        char * pData = new char[iBufLenth];    
        Read(pData ,m_iDataLenth);
    
        delete []m_PData;
        m_PData = pData;
        m_iReadPos = 0;
        m_iWritePos = m_iDataLenth;
        m_iBufLenth = iBufLenth;
    }
    return  m_iDataLenth;
}

void CMindryBuffer::Clear()
{
    m_iReadPos = 0;
    m_iWritePos = 0;
    m_iDataLenth = 0;
}

int    CMindryBuffer::GetCapicity()
{
    return m_iBufLenth;
}

int    CMindryBuffer::GetWriteAvailable()
{
    return m_iBufLenth -m_iDataLenth;

}
int    CMindryBuffer::GetReadAvailable()
{
    return m_iDataLenth;
}

int _tmain(int argc, _TCHAR* argv[])
{    
    
    CMindryBuffer mindBuf;

    int iReadLenth;
    char buf[100];
    mindBuf.Write("abcd",4);
    
    iReadLenth = mindBuf.Read(buf,1);
    buf[iReadLenth] = 0;
    cout<<buf<<endl;

    mindBuf.Write("efghi",5);
    iReadLenth = mindBuf.Read(buf,5);
    buf[iReadLenth] = 0;
    cout<<buf<<endl;

    mindBuf.Write("gklmn",5);
    iReadLenth = mindBuf.Read(buf,8);
    buf[iReadLenth] = 0;
    cout<<buf<<endl;
    

    return 0;
}