多线程 c++ 环形队列

#ifndef RING_BUFFER_H
#define RING_BUFFER_H
#include <mutex>

template<typename T, int N>
class RingBuf
{
public:
    RingBuf();

    ~RingBuf();

    bool get(T& a);

    bool put(T a);

private:

    inline bool isFull();
    inline bool isEmpty();
    void msg();

    T buf[N];
    int first;
    int last;
    int size;
    const int capSize;
    std::mutex m_mutex;
};
#include "RingBuffer.cpp"
#endif

 

 

 

#ifdef  RING_BUFFER_H
#include "RingBuffer.h"
#include <iostream>

template<typename T, int N>
RingBuf<T,N>::RingBuf()
    : capSize(N)
{
        first = last = 0;
        size = 0;
}

template<typename T, int N>
RingBuf<T, N>::~RingBuf() {

}

template<typename T, int N>
    bool RingBuf<T, N>::get(T& a) {
        std::lock_guard<std::mutex> locker(m_mutex);
        if (isEmpty()) {
            return false;
        }
        
        a = buf[first++];
        first %= capSize;
        size -= 1;
        return true;
    }

    template<typename T, int N>
    bool RingBuf<T, N>::put(T a) {
        std::lock_guard<std::mutex> locker(m_mutex);

        buf[last] = a;
        last += 1;
        last %= capSize;
        if (isFull()) {
            first += 1;
            first %= capSize;
        }
        else {
            size += 1;
        }
        return true;
    }

    template<typename T, int N>
    inline bool RingBuf<T, N>::isFull() {
        return size == capSize;
    }

    template<typename T, int N>
    inline bool RingBuf<T, N>::isEmpty() {
        return size == 0;
    }

    template<typename T, int N>
    void RingBuf<T, N>::msg() {
        std::lock_guard<std::mutex> locker(m_mutex);

        for (int i = 0; i < size; ++i) {
            int ix = (first + i) % capSize;
            std::cout << buf[ix] << " ";
            if (i == size - 1) {
                std::cout << "\n";
            }
        }
        if (size == 0) {
            std::cout << " \n";
        }
    }
#endif