基于C++的ringbuffer环形队列_c++ ringbuffer

C++有锁环形队列

先来一段来自gpt的环形队列介绍
环形队列是一种数据结构，通常用于实现循环缓冲区或者循环队列。它与普通队列的不同之处在于，当队列尾部到达数组的末尾时，下一个元素会被放置在数组的开头，实现循环的效果，从而节省空间。
环形队列通常由一个固定大小的数组和两个指针（头指针和尾指针）组成。头指针指向队列的第一个元素，尾指针指向队列最后一个元素的下一个位置。
插入操作时，尾指针向前移动，元素被插入到尾指针指向的位置。如果尾指针到达数组末尾，则将其置为数组开头。删除操作时，头指针向前移动，删除头指针指向的元素。
这种数据结构的优点是能够有效地利用固定大小的数组空间，并且支持高效的入队和出队操作。然而，由于其固定大小的特性，一旦队列已满，再插入元素会导致队列溢出。

以下是C++实现
1:使用std::vector<uint8_t>作为底层数据结构
2:使用head,tail索引代替指针
3:支持多种形式的连续入队
void pushMultiple(const std::vector& values);
void pushMultiple(const T* data,uint32_t len);
4:支持多个出队
std::vector popAll();

#ifndef __LOOPBUFFER__
#define __LOOPBUFFER__

#include <mutex>
#include <vector>
#include "spdlog/spdlog.h"
#include <stdint.h>

/**
 * @description: 环形队列模板类
 */
template<typename T>
class LoopBuffer 
{
public:
    explicit LoopBuffer(const char* name_,uint32_t capacity);

    ~LoopBuffer();

    /**
     * @description: 
     * @param {T&} value
     * @return {*}
     */
    void push(const T& value);

    /**
     * @description: 
     * @param const std::vector<T>& values
     * @return {*}
     */    
    void pushMultiple(const std::vector<T>& values);

    /**
     * @description: 
     * @param {const T*} data
     * @param {uint32_t} len
     * @return {*}
     */    
    void pushMultiple(const T* data,uint32_t len);

    /**
     * @description: 单个出队
     * @return {*}
     */    
    T pop();

    /**
     * @description: 多个出队
     * @return {std::vector<T>}
     */    
    std::vector<T> popAll();

    /**
     * @description: 队列是否为空
     * @return {bool}
     */    
    bool isEmpty() const;

    /**
     * @description: 队列是否为满
     * @return {bool}
     */    
    bool isFull() const;

    /**
     * @description: 获取队列名
     * @return {const char*}
     */    
    const char* getter_loopbuffer_name() const;

    /**
     * @description: 获取队列总容量
     * @return {*}
     */    
    uint32_t getter_loopbuffer_capacity() const;


    /**
     * @description: 获取当前已存数据大小
     * @return {*}
     */    
    uint32_t getter_loopbuffer_cursize() const;


public:
    LoopBuffer() = delete;//默认构造
    LoopBuffer& operator=(const LoopBuffer&) = delete;//赋值构造
    LoopBuffer(const LoopBuffer&) = delete;//拷贝构造
    LoopBuffer(LoopBuffer&&) = delete;//移动构造

private:
    std::mutex mutex_m;
    std::vector<T> buffer_m; //环形队列载体
    uint32_t head_m;           //头
    uint32_t tail_m;           //尾
    uint32_t size_m;           //环形队列已存数据量大小
    const char* name_m;      //环形队列名字
};

template<typename T>
LoopBuffer<T>::LoopBuffer(const char* name_,uint32_t capacity):   buffer_m(capacity),//设置环形队列载体大小
                                                                head_m(0), //头部置0
                                                                tail_m(0), //尾部置0
                                                                size_m(0), //环形队列已存数据量大小置0
                                                                name_m(name_) //名字
{
}

template<typename T>
LoopBuffer<T>::~LoopBuffer()
{
    
}

template<typename T>
void LoopBuffer<T>::push(const T& value) 
{
    std::lock_guard<std::mutex> lock(mutex_m);
    if(isFull()) //判断队列是否已满
    {
        SPDLOG_WARN("loopbuffer[{}] is full size[{}] head[{}] tail[{}]",name_m,size_m,head_m,tail_m);
        buffer_m[head_m] = value; //已满,从头部开始覆盖
        head_m = (head_m + 1) % buffer_m.size();//头部位置移动，因为已满，size_m处于最大值，不对size_m操作，此时仍为满的状态
    }else 
    {
        buffer_m[tail_m] = value; //未满，放入尾部
        tail_m = (tail_m + 1) % buffer_m.size();//尾部位置移动
        size_m++;//队列已存数据量自增加
    }
}

template<typename T>
void LoopBuffer<T>::pushMultiple(const std::vector<T>& values) 
{
    for (int value : values) //循环放入队列
    {
        push(value);
    }
}

template<typename T>
void LoopBuffer<T>::pushMultiple(const T* data,uint32_t len) 
{
    for(uint32_t i = 0; i < len; i++)//循环放入队列
    {
        push(data[i]);
    }
}

template<typename T>
T LoopBuffer<T>::pop() 
{
    std::lock_guard<std::mutex> lock(mutex_m);
    if (isEmpty()) //判断出队
    {
        throw std::runtime_error("Buffer_m is empty");//抛出异常，外部使用pop时需要捕捉异常
    }
    T value = buffer_m[head_m]; //从头部开始出队
    head_m = (head_m + 1) % buffer_m.size(); //头部移动
    size_m--; //环形队列已存数据量大小自减
    return value;
}

template<typename T>
std::vector<T> LoopBuffer<T>::popAll() 
{
    std::vector<T> allValues;
    while (!isEmpty()) //一直出队直到队列为空
    {
        allValues.push_back(pop());
    }
    return allValues;
}

template<typename T>
bool LoopBuffer<T>::isEmpty() const 
{
    return size_m == 0; //环形队列已存数据量大小为0,即为空
}

template<typename T>
bool LoopBuffer<T>::isFull() const 
{
    return size_m == buffer_m.size();//环形队列已存数据量大小和队列容量一致为满
}

template<typename T>
const char* LoopBuffer<T>::getter_loopbuffer_name() const
{
    return name_m;
}

template<typename T>
uint32_t LoopBuffer<T>::getter_loopbuffer_capacity() const
{
    return buffer_m.size();
}

template<typename T>
uint32_t LoopBuffer<T>::getter_loopbuffer_cursize() const
{
    return size_m;

}
#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206