// BufferRW.h
#ifndef __BUFFERRW_H__INCLUDED__
#define __BUFFERRW_H__INCLUDED__

class CBuffer
{
protected:
    unsigned char* m_pBuffer;  // バッファ
    int            m_nSize;    // バッファサイズ
    int            m_nPos;     // 現在位置

public:
    CBuffer(int nSize);
    virtual ~CBuffer();

public:
    int SetPos(int nPos);  // 位置設定
    int AddPos(int nAdd);  // 位置を進ませる
};

class CBufferRead : virtual public CBuffer
{
public:
    CBufferRead(int nSize);

public:
    // バッファから読み出す
    int Read(void* pRead, int nReadSize,
             int nUnit = 1);
};

class CBufferWrite : virtual public CBuffer
{
public:
    CBufferWrite(int nSize);

public:
    // バッファに書き込む
    int Write(const void* pWrite, int nWriteWord,
              int nUnit = 1);
};

class CBufferRW : public CBufferRead,
                  public CBufferWrite
{
public:
    CBufferRW(int nSize);
};

#endif // #ifndef __BUFFERRW_H__INCLUDED__

// BufferRW.cpp
#include "BufferRW.h"
#include <memory.h>
#include <new>

CBuffer::CBuffer(int nSize)
    : m_pBuffer(NULL), m_nSize(0), m_nPos(0)
{
    m_pBuffer = new unsigned char[nSize];
    if(m_pBuffer == NULL)
        throw std::bad_alloc();  // 例外を投げます
    m_nSize = nSize;

    memset(m_pBuffer, 0, nSize);
}

CBuffer::~CBuffer()
{
    if(m_pBuffer != NULL)
    {
        delete [] m_pBuffer;
        m_pBuffer = NULL;  // 一応、ね
    }
}

// 位置設定
int CBuffer::SetPos(int nPos)
{
    if(nPos > m_nSize)
        m_nPos = m_nSize;
    else if(nPos < 0)
        m_nPos = 0;
    else
        m_nPos = nPos;
    return m_nPos;
}

// 位置を進ませる
int CBuffer::AddPos(int nAdd)
{
    return SetPos(m_nPos + nAdd);
}

CBufferRead::CBufferRead(int nSize) : CBuffer(nSize){ }

// バッファから読み出す
int CBufferRead::Read(
    void* pRead, int nReadWord, int nUnit)
{
    // 残り単位
    const int nLeftWord = (m_nSize - m_nPos) / nUnit;
    if(nReadWord > nLeftWord)  // 読み込みすぎのとき
        nReadWord = nLeftWord;

    // 読み込みサイズ
    const int nReadSize = nReadWord * nUnit;
    memcpy(pRead, m_pBuffer + m_nPos, nReadSize);
    m_nPos += nReadSize;
    return nReadWord;
}

CBufferWrite::CBufferWrite(int nSize) : CBuffer(nSize){ }

// バッファに書き込む
int CBufferWrite::Write(
    const void* pWrite, int nWriteWord, int nUnit)
{
    // 残り単位
    const int nLeftWord = (m_nSize - m_nPos) / nUnit;
    if(nWriteWord > nLeftWord)  // 読み込みすぎのとき
        nWriteWord = nLeftWord;

    // 読み込みサイズ
    const int nWriteSize = nWriteWord * nUnit;
    memcpy(m_pBuffer + m_nPos, pWrite, nWriteSize);
    m_nPos += nWriteSize;
    return nWriteWord;
}