再开源一个C++模板环形队列类，避免重复造轮子。

tengye

大家最好不要在中断里面用STL.在业务层可以用。
/*****************************************************************
  Copyright (c), 2020-2021, tengye DH Biotechnology Co., Ltd
  Description:     
环形队列
可以用在中断中快速读取，性能非常接近C语言。
*****************************************************************/
#ifndef    __circularqueue_H
#define    __circularqueue_H

#include <assert.h>
#ifndef NULL
    #define NULL 0
#endif
template <typename T>
class CircularQueue
{
public:
    CircularQueue(int maxData, T* buf)
    {
        Init(maxData, buf);
    }

    CircularQueue()
    {
        m_buf     = NULL;
        m_maxData = 0;
        m_front   = 0;
        m_rear    = 0;
    }
               
    virtual ~CircularQueue()
    {
    }
                 
public:
    void Init(int maxData, T* buf)
    {
        assert(maxData > 1);
        assert(buf != NULL);

        m_buf     = buf;
        m_maxData = maxData;
        m_front   = 0;
        m_rear    = 0;
    }

    bool Pop(T& ret)
    {
        assert(m_maxData > 1);
        assert(m_buf != NULL);

        if (m_rear != m_front)
        {
            int front = (m_front + 1) % m_maxData;
            ret = m_buf[front];
            m_front = front;

            return true;
        }
        else
        {
            return false;
        }
    }

    bool Front(T& ret)
    {
        assert(m_maxData > 1);
        assert(m_buf != NULL);

        if (m_rear != m_front)
        {
            int front = (m_front + 1) % m_maxData;
            ret = m_buf[front];

            return true;
        }
        else
        {
            return false;
        }
    }

    bool Push(T& dat)
    {
        const T& ref = dat;
        return Push(ref);
    }
               
    bool Push(const T& dat)
    {
        assert(m_maxData > 1);
        assert(m_buf != NULL);

        int rear = (m_rear + 1) % m_maxData;

        if (rear != m_front)
        {
            m_buf[rear] = dat;
            m_rear = rear;

            return true;
        }
        else
        {
            return false;
        }
    }               
    inline int GetElementCount()
    {
        assert(m_maxData > 1);
        assert(m_buf != NULL);

        return (m_rear + m_maxData - m_front) % m_maxData;
    }

    inline int GetCanPushMaxSize()
    {
        assert(m_maxData > 1);
        assert(m_buf != NULL);

        return m_maxData - 1;
    }

    inline void Flush()
    {
        assert(m_maxData > 1);
        assert(m_buf != NULL);

        m_front = 0;
        m_rear = 0;
    }

protected:
    int  m_front;
    int  m_rear;
    int  m_maxData;
    T*   m_buf;
};

#endif