循环队列——实现ringbuffer为了多媒体数据缓存

青旅半醒 2022-06-13 11:51 230阅读 0赞

http://blog.csdn.net/firehood\_/article/details/6716357

在WINCE开发中很多时候需要用到循环队列来缓存数据，比如在串口通信中，可以将接收到的数据流先缓存到循环队列中，然后再从循环队列中取出数据做下一步的处理。这样可以有效的避免解析数据帧时繁琐的拼接处理。

为了方便使用，封装了一个循环队列类，具体代码如下：

头文件：

**\[cpp\]**  [view plain][]   [copy][view plain]

源文件:

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* 
2.  filename:   CircularQueue.cpp 
3.  created:    2011-08-23 
4.  author:     firehood 
5.   
6.  purpose:    实现循环队列 
7.              队列可以缓存的数据大小 = 队列长度 -1 
8.              插入数据时在队列满的情况下会自动覆盖队列头部数据 
9.  \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
10. \#include "stdafx.h"  
11. \#include "CircularQueue.h"  
12.   
13. CCircularQueue::CCircularQueue(**void**):  
14. m\_pQueueBase(NULL),  
15. m\_Head(0),  
16. m\_Tail(0),  
17. m\_QueueSize(DEFAULT\_QUEUE\_MAX\_SIZE)  
18. \{  
19.     m\_pQueueBase = **new** unsigned **char**\[m\_QueueSize\];  
20.     ASSERT(m\_pQueueBase);  
21.     memset(m\_pQueueBase, 0, m\_QueueSize);  
22.     InitializeCriticalSection(&m\_csRW);  
23. \}  
24.   
25. CCircularQueue::CCircularQueue(**int** nQueueSize):  
26. m\_pQueueBase(NULL),  
27. m\_Head(0),  
28. m\_Tail(0),  
29. m\_QueueSize(nQueueSize)  
30. \{  
31.     m\_pQueueBase = **new** unsigned **char**\[m\_QueueSize\];  
32.     ASSERT(m\_pQueueBase);  
33.     memset(m\_pQueueBase, 0, m\_QueueSize);  
34.     InitializeCriticalSection(&m\_csRW);  
35. \}  
36.   
37. CCircularQueue::~CCircularQueue(**void**)  
38. \{  
39.     **if**(m\_pQueueBase)  
40.     \{  
41.         **delete**\[\] m\_pQueueBase;  
42.         m\_pQueueBase = NULL;  
43.     \}  
44.     DeleteCriticalSection (&m\_csRW);  
45. \}  
46.   
47. // 向队列尾部插入一个字节，队列满时会自动覆盖队列头部数据  
48. **bool** CCircularQueue::PushBack(unsigned **char** data)  
49. \{  
50.     **if**(m\_pQueueBase == NULL)  
51.     \{  
52.         **return** **false**;  
53.     \}  
54.     EnterCriticalSection(&m\_csRW);  
55.   
56.     m\_pQueueBase\[m\_Tail\]= data;  
57.     m\_Tail =(m\_Tail+1) % m\_QueueSize;  
58.     **if**(m\_Tail == m\_Head)  
59.     \{  
60.         m\_Head = m\_Tail+1;  
61.         printf("Warning:lost data, Queue is full..\\n");  
62.     \}  
63.   
64.     LeaveCriticalSection(&m\_csRW);  
65.     **return** **true**;  
66. \}  
67.   
68. // 从队列头部取出一个字节  
69. **bool** CCircularQueue::PopFront(unsigned **char** &data)  
70. \{  
71.     **if**(m\_pQueueBase == NULL)  
72.     \{  
73.         **return** **false**;  
74.     \}  
75.     **if**(IsEmpty())  
76.     \{  
77.         **return** **false**;  
78.     \}  
79.     EnterCriticalSection(&m\_csRW);  
80.   
81.     data = m\_pQueueBase\[m\_Head\];  
82.     m\_Head=(m\_Head+1) % m\_QueueSize;  
83.   
84.     LeaveCriticalSection(&m\_csRW);  
85.     **return** **true**;  
86. \}  
87.   
88. // 向队列尾部插入指定长度数据，队列满时会自动覆盖队列头部数据  
89. **bool** CCircularQueue::PushBack(unsigned **char** \*pData, **int** size)  
90. \{  
91.     **if**(m\_pQueueBase == NULL || pData == NULL)  
92.     \{  
93.         **return** **false**;  
94.     \}  
95.     **if**(size >= m\_QueueSize)  
96.     \{  
97.         printf("PushBack failed: DataSize\[%d\] > MAX\_QUEUE\_SIZE\[%d\]\\n" , size, (m\_QueueSize-1));  
98.         **return** **false**;  
99.     \}  
100.     EnterCriticalSection(&m\_csRW);  
101.     **int** nRemianSize = RemainSize();  
102.     **int** nTailToEndSize = m\_QueueSize - m\_Tail;  
103.     **if**(size <= nTailToEndSize)  
104.     \{  
105.         memcpy(m\_pQueueBase+m\_Tail, pData, size);  
106.     \}  
107.     **else**  
108.     \{  
109.         memcpy(m\_pQueueBase+m\_Tail, pData, nTailToEndSize);  
110.         memcpy(m\_pQueueBase,pData+nTailToEndSize, size-nTailToEndSize);  
111.     \}  
112.     m\_Tail = (m\_Tail+size) % m\_QueueSize;  
113.     **if**(size >= nRemianSize)  
114.     \{  
115.         printf("Warning:lost data, Queue is full..\\n");  
116.         m\_Head = m\_Tail+1;  
117.     \}  
118.     LeaveCriticalSection(&m\_csRW);  
119.     **return** **true**;  
120. \}  
121.   
122. // 从队列头部取出指定长度数据  
123. // 返回值：>0 返回实际取出的数据长度； <=0 失败  
124. **int** CCircularQueue::PopFront(unsigned **char** \*pData, **int** size)  
125. \{  
126.     **if**(pData == NULL || m\_pQueueBase == NULL)  
127.         **return** -1;  
128.       
129.     EnterCriticalSection(&m\_csRW);  
130.     **int** nReadSize = (**this**\->Size()>size) ? size : **this**\->Size();  
131.     **int** nHeadToEndSize = m\_QueueSize - m\_Head;  
132.     **if**(nReadSize <= nHeadToEndSize)  
133.     \{  
134.         memcpy(pData, m\_pQueueBase+m\_Head, nReadSize);  
135.     \}  
136.     **else**  
137.     \{  
138.         memcpy(pData,m\_pQueueBase+m\_Head, nHeadToEndSize);  
139.         memcpy(pData+nHeadToEndSize,m\_pQueueBase,nReadSize-nHeadToEndSize);  
140.     \}  
141.     m\_Head=(m\_Head+nReadSize) % m\_QueueSize;  
142.     LeaveCriticalSection(&m\_csRW);  
143.     **return** nReadSize;  
144. \}  
145.   
146. // 当前队列缓存的数据大小  
147. **int** CCircularQueue::Size()  
148. \{  
149.     **return** (m\_Tail-m\_Head+m\_QueueSize) % m\_QueueSize;  
150. \}  
151.   
152. // 队列是否为空  
153. **bool** CCircularQueue::IsEmpty()  
154. \{  
155.     **return** (m\_Head == m\_Tail) ? **true** : **false**;  
156. \}  
157.   
158. // 队列是否满   
159. **bool** CCircularQueue::IsFull()  
160. \{  
161.     **return** (((m\_Tail+1) % m\_QueueSize) == m\_Head) ? **true** : **false**;  
162. \}  
163.   
164. // 队列当前剩余空间大小  
165. **int** CCircularQueue::RemainSize()  
166. \{  
167.     **return** ((m\_QueueSize-1)-Size());  
168. \}  
169.   
170. // 打印数据  
171. **void** CCircularQueue::PrintData()  
172. \{  
173.     **int** tempHead, tempTail;  
174.     tempHead = m\_Head;  
175.     tempTail = m\_Tail;  
176.     printf("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\\n");  
177.     printf("CirualarQueue Data:");  
178.     **while**(tempHead != tempTail)  
179.     \{  
180.         printf("0x%02x ", m\_pQueueBase\[tempHead\]);  
181.         tempHead=(tempHead+1) % m\_QueueSize;  
182.     \}  
183.     printf("\\n");  
184.     printf("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\\n");  
185. \}  
186.   
187. // 重新调整队列大小  
188. **bool** CCircularQueue::Resize(**int** nQueueSize)  
189. \{  
190.     unsigned **char** \*pNewQueue = NULL;  
191.     // 申请新的队列空间  
192.     pNewQueue = **new** unsigned **char**\[nQueueSize\];  
193.     **if**(pNewQueue == NULL) // 申请内存失败  
194.         **return** **false**;  
195.     // 将队列原有数据拷贝到新队列中  
196.     **int** len = PopFront(pNewQueue,nQueueSize);  
197.     // 释放原来队列空间  
198.     **if**(m\_pQueueBase)  
199.     \{  
200.         **delete**\[\] m\_pQueueBase;  
201.         m\_pQueueBase = NULL;  
202.     \}  
203.     // 使用新的队列空间  
204.     m\_pQueueBase = pNewQueue;  
205.     m\_QueueSize = nQueueSize;  
206.     m\_Head = 0;  
207.     m\_Tail = len;  
208.     **return** **true**;  
209. \}

顶

踩

*  上一篇[Winodws HOOK 之键盘钩子][Winodws HOOK]
 *  下一篇[printf、fprintf变参函数封装][printf_fprintf]
 *

[view plain]: http://blog.csdn.net/firehood_/article/details/6716357#
[Winodws HOOK]: http://blog.csdn.net/feihu521a/article/details/6624384
[printf_fprintf]: http://blog.csdn.net/feihu521a/article/details/6823154