Динамический размер кольцевого буфера(ФИФО)

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <conio.h>
 
// буфер для записи и копирования
class CMyBuff
{
public:
    // характеристики пакета
    struct SPacket
    {
        int iOffset; // смещение в секции данных
        int iSize; // размер данных
    };
 
protected:
    std::mutex m_mutex; // межпотоковая блокировка
 
    // описание пакетов
    int m_iPacketMaxCount; // максимальное количество пакетов
    int m_iPacketHead; // индекс следующего пакета
    int m_iPacketTail; // индекс последнего пакета
    SPacket* m_pPacket; // пакеты
 
    // данные пакетов
    int m_iDataMaxSize; // максимальный размер данных (должно быть достаточно, что бы вместить все пакеты)
    int m_iDataOffset; // смещение для следующей записи
    int m_iDataSize; // общий размер данных
    char* m_pData; // буфер под данные пакетов
 
public:
    // конструктор
    CMyBuff()
    {
        m_pPacket = 0;
        m_pData = 0;
        Clean();
    }
 
    // деструктор
    ~CMyBuff()
    {
        Clean();
    }
 
    // очистить память
    void Clean()
    {
        m_iPacketMaxCount = m_iPacketHead = m_iPacketTail = 0;
        if (m_pPacket)
        {
            delete[] m_pPacket;
            m_pPacket = 0;
        }
 
        m_iDataMaxSize = m_iDataOffset = m_iDataSize = 0;
        if (m_pData)
        {
            delete[] m_pData;
            m_pData = 0;
        }
    }
 
    // выделить память под пакеты и данные
    bool Init(int iPacketMaxCount, int iDataMaxSize)
    {
        Clean();
 
        if ((iPacketMaxCount <= 1) || (iDataMaxSize <= 0))
            return false; // ошибочные аргументы
 
        m_iPacketMaxCount = iPacketMaxCount;
        m_pPacket = new SPacket[iPacketMaxCount];
 
        m_iDataMaxSize = iDataMaxSize;
        m_pData = new char[iDataMaxSize];
 
        return true;
    }
 
    // добавить пакет (блокируется)
    bool AddPacket(const char* pData, int iSize)
    {
        if (!pData || (iSize <= 0) || !m_pData || !m_pPacket)
            return false;
 
        std::lock_guard<std::mutex> lck(m_mutex);
 
        // суммарный размер пакетов в кольце
        int iDataSize = m_iDataSize;
        if (((m_iPacketHead + 1) % m_iPacketMaxCount) == m_iPacketTail) // есть затирание старого пакета
            iDataSize -= m_pPacket[m_iPacketTail].iSize;
 
        if ((iDataSize + iSize) > m_iDataMaxSize)
            return false; // не влезает, размер задан ошибочно
 
        // новый размер данных
        m_iDataSize = iDataSize + iSize;
 
        // добавляем пакет
        m_pPacket[m_iPacketHead].iOffset = m_iDataOffset;
        m_pPacket[m_iPacketHead].iSize = iSize;
        // индекс следующего пакета
        m_iPacketHead++;
        if (m_iPacketHead == m_iPacketMaxCount)
            m_iPacketHead = 0;
        // индекс последнего пакета
        if (m_iPacketTail == m_iPacketHead)
        {
            m_iPacketTail++;
            if (m_iPacketTail == m_iPacketMaxCount)
                m_iPacketTail = 0;
        }
 
        // копируем данные
        if (m_iDataOffset + iSize <= m_iDataMaxSize)
        {
            // копируем за один раз
            memcpy(m_pData + m_iDataOffset, pData, iSize);
            // новое смещение
            m_iDataOffset += iSize;
            if (m_iDataOffset == m_iDataMaxSize)
                m_iDataOffset = 0;
        }
        else
        {
            // копируем за два раза
            int iSubSize = m_iDataMaxSize - m_iDataOffset;
            memcpy(m_pData + m_iDataOffset, pData, iSubSize);
            memcpy(m_pData, pData + iSubSize, iSize - iSubSize);
            // новое смещение
            m_iDataOffset = iSize - iSubSize;
        }
 
        return true;
    }
 
    // сделать копию (источник блокируется)
    bool Copy(CMyBuff* pSrc)
    {
        if (!pSrc || !pSrc->m_pData || !pSrc->m_pPacket)
            return false;
 
        std::lock_guard<std::mutex> lck(pSrc->m_mutex);
 
        // выделяем память
        if ((m_iPacketMaxCount != pSrc->m_iPacketMaxCount) || (m_iDataMaxSize != pSrc->m_iDataMaxSize))
        {
            if (!Init(pSrc->m_iPacketMaxCount, pSrc->m_iDataMaxSize))
                return false;
        }
 
        // копируем данные
        m_iDataOffset = 0;
        m_iDataSize = pSrc->m_iDataSize;
        int iStartOffset = pSrc->m_iDataOffset - pSrc->m_iDataSize;
        if (iStartOffset < 0)
        {
            memcpy(m_pData, pSrc->m_pData + pSrc->m_iDataMaxSize + iStartOffset, -iStartOffset);
            memcpy(m_pData - iStartOffset, pSrc->m_pData, pSrc->m_iDataSize + iStartOffset);
        }
        else
        {
            memcpy(m_pData, pSrc->m_pData + iStartOffset, pSrc->m_iDataSize);
        }
 
        // копируем пакеты
        m_iPacketHead = m_iPacketTail = 0;
        int iPos = pSrc->m_iPacketTail;
        int iOfs = 0;
        while (iPos != pSrc->m_iPacketHead)
        {
            m_pPacket[m_iPacketHead].iSize = pSrc->m_pPacket[iPos].iSize;
            m_pPacket[m_iPacketHead].iOffset = iOfs;
            iOfs += m_pPacket[m_iPacketHead].iSize;
 
            m_iPacketHead++;
            
            iPos++;
            if (iPos >= pSrc->m_iPacketMaxCount)
                iPos = 0;
        }
 
        return true;
    }
 
    // указатель на данные
    const char* GetDataPtr()
    {
        return m_pData;
    }
 
    // размер данных
    int GetDataSize()
    {
        return m_iDataSize;
    }
    
    // количество пакетов
    int GetPacketsCount()
    {
        int iCount = m_iPacketHead - m_iPacketTail;
        if (iCount < 0)
            iCount += m_iPacketMaxCount;
        return iCount;
    }
 
    // информация о пакете
    const SPacket* GetPacketInfo(int index)
    {
        if ((index < 0) || (index >= GetPacketsCount()))
            return 0;
 
        int iPos = m_iPacketTail + index;
        if (iPos >= m_iPacketMaxCount)
            iPos -= m_iPacketMaxCount;
 
        return &m_pPacket[iPos];
    }
};
 
// тестовый приёмник данных
// 1) генерируем пакеты текста из последовательных чисел от 0 до 10000
// 2) генерируем пакеты текста из случайных чисел от 0 до 10000
void reciver_test_thread(CMyBuff* pBuf, bool* pStopThread)
{
    int iNum = 0;
    char chBuffer[100];
    srand(time(0));
 
    while (!(*pStopThread))
    {
        // ждать 1 мс
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
        // формируем пакет из последовательных или случайных чисел
        if (true)
        {
            sprintf(chBuffer, "%d ", iNum);
            // следующее число
            if (++iNum == 10000)
                iNum = 0;
        }
        else
        {
            sprintf(chBuffer, "%d ", rand() % 10000);
        }
 
        // добавить пакет в буфер
        if (!pBuf->AddPacket(chBuffer, strlen(chBuffer)))
        {
            std::cout << "AddPacket() - failed" << std::endl;
            break;
        }
    }
}
 
// тест
int main(int argc, char* argv[])
{
    CMyBuff rec_buf;
    rec_buf.Init(10+1, 1024); // 10 пакетов, содержимое которых должно поместиться в 1024 байтах
 
    // переменная для остановки потока
    bool bStopThread = false;
 
    // запустить тестовый поток
    std::thread test(reciver_test_thread, &rec_buf, &bStopThread);
    
    // ждать 0.5 сек
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
 
    CMyBuff copy_buf;
 
    // пока не нажали кнопку
    while (!kbhit())
    {
        // копировать данные из буфера приёмника во временный буфер
        if (!copy_buf.Copy(&rec_buf))
        {
            std::cout << "Copy() - failed" << std::endl;
            break;
        }
 
        // вывести строку из буфера (скопированные данные лежат одним куском с начала буфера)
        std::cout.write(copy_buf.GetDataPtr(), copy_buf.GetDataSize());
        std::cout << std::endl;
        
        // ждать 1.5 сек
        std::this_thread::sleep_for(std::chrono::milliseconds(1500));
    }
 
    // останавливаем поток
    bStopThread = true;
    if (test.joinable())
        test.join();
 
    std::cout << "finished" << std::endl;
    std::cin.ignore();
    return 0;
}