教你使用真正的queue

samos2011

教你使用真正的queue [复制链接]

1. 
   
2. template<class U>
   
3. class queue{
   
4.   protected:
   
5.                 int         deIndex;
   
6.                 int         enIndex;
   
7.                 U*         items;
   
8.                 int         itemMax;
   
9.                 bool freeMem;        
   
10.         
    
11.   public:
    
12.                 queue(int count){
    
13.                         Init(count);        
    
14.                 }
    
15.                 queue(U* buff,int count){
    
16.                         Init(buff,count);
    
17.                 }
    
18.                 queue(){
    
19.                         enIndex = 0;
    
20.                         deIndex = 0;
    
21.                         itemMax = 0;
    
22.                         freeMem = false;
    
23.                 }
    
24.                 ~queue(){
    
25.                         itemMax = 0;
    
26.                         if(freeMem){
    
27.                                 delete[] items;
    
28.                         }
    
29.                         enIndex = 0;
    
30.                         deIndex = 0;
    
31.                         freeMem = false;
    
32.                 }
    
33.                 void Init(int count){        
    
34.                         enIndex = 0;
    
35.                         deIndex = 0;
    
36.                         items = new U[count];
    
37.                         freeMem = true;
    
38.                         itemMax = count;        
    
39.                 }
    
40.                 void Init(U* buff,int count){
    
41.                         enIndex = 0;
    
42.                         deIndex = 0;
    
43.                         items = buff;
    
44.                         freeMem = false;        
    
45.                         itemMax = count;                                
    
46.                 }
    
47.                 void Clear(void){
    
48.                         deIndex = enIndex;
    
49.                 }
    
50.                 int CountToWrite(void){
    
51.                         if(itemMax == 0){
    
52.                                 return 0;
    
53.                         }
    
54.                         return itemMax - CountToRead() - 1;
    
55.                 }
    
56.                 int CountToRead(void){
    
57.                         int c = 0;
    
58.                         volatile int deIndex_bak;
    
59.                         volatile int enIndex_bak;
    
60.                         deIndex_bak = deIndex;
    
61.                         enIndex_bak = enIndex;
    
62.                         if(deIndex_bak > enIndex_bak){
    
63.                                 c = (itemMax - deIndex_bak) + enIndex_bak;
    
64.                         }else{
    
65.                                 c = enIndex_bak - deIndex_bak;
    
66.                         }
    
67.                         return c;                        
    
68.                 }
    
69.                 int UseRate(void){
    
70.                         int x = CountToRead();
    
71.                         int y = itemMax;
    
72.                         if(y == 0){
    
73.                                 return 100;
    
74.                         }
    
75.                         return (x*100)/y;
    
76.                 }
    
77.                 int EnQueue(U& item){
    
78.                         volatile int x;
    
79.                         if(CountToWrite()){
    
80.                                 x = enIndex;
    
81.                                 items[x++] = item;
    
82.                                 if(x >= itemMax){
    
83.                                         x = 0;
    
84.                                 }
    
85.                                 enIndex = x;
    
86.                                 return 1;
    
87.                         }
    
88.                         return 0;
    
89.                 }
    
90.                 int EnQueue(U buf[],int count){
    
91.                         volatile int x;
    
92.                         x = CountToWrite();
    
93.                         if(x < count){
    
94.                                 count = x;
    
95.                         }
    
96.                         x = enIndex;
    
97.                         for(int i = 0;i < count;i++){
    
98.                                 items[x++] = buf[i];        
    
99.                                 if(x >= itemMax){
    
100.                                         x = 0;
     
101.                                 }
     
102.                         }
     
103.                         enIndex = x;
     
104.                         return count;                        
     
105.                 }
     
106.                 U DeQueue(void){
     
107.                         volatile int i=0,x;
     
108.                         if(CountToRead()){
     
109.                                 x = deIndex;
     
110.                                 i = deIndex;        
     
111.                                 x++;        
     
112.                                 if(x >= itemMax){
     
113.                                         x = 0;
     
114.                                 }
     
115.                                 deIndex = x;        
     
116.                         }        
     
117.                         return items[i];        
     
118.                 }
     
119.                 int DeQueue(U& item){
     
120.                         volatile int x;
     
121.                         if(CountToRead()){
     
122.                                 x = deIndex;
     
123.                                 item = items[x++];
     
124.                                 if(x >= itemMax){
     
125.                                         x = 0;
     
126.                                 }
     
127.                                 deIndex = x;               
     
128.                                 return 1;        
     
129.                         }
     
130.                         return 0;
     
131.                 }
     
132.                 int DeQueue(U buf[],int count){
     
133.                         volatile int x;
     
134.                         x = CountToRead();
     
135.                         if(x < count){
     
136.                                 count = x;
     
137.                         }
     
138.                         x = deIndex;
     
139.                         for(int i = 0;i < count;i++){
     
140.                                 buf[i] = items[x++];
     
141.                                 if(x >= itemMax){
     
142.                                         x = 0;
     
143.                                 }
     
144.                         }
     
145.                         deIndex = x;
     
146.                         return count;                        
     
147.                 }
     
148.                 int Count(void){
     
149.                         return CountToRead();
     
150.                 }
     
151. };
     
152. 
     
153. // 假设这是CAN消息数据类型定义,使用了ARMCC的匿名联合属性
     
154. #pragma push
     
155. #pragma anon_unions
     
156. union CAN_Message{
     
157.         struct{
     
158.                 unsigned int DA;
     
159.                 unsigned int DB;
     
160.                 unsigned int ID;
     
161.                 unsigned char format; // 0 - STANDARD, 1- EXTENDED IDENTIFIER
     
162.                 unsigned char type;   // 0 - DATA FRAME, 1 - REMOTE FRAME
     
163.                 unsigned char len;               
     
164.                 unsigned char ctrl;        
     
165.         };
     
166.         struct{
     
167.                 short v0;
     
168.                 short v1;
     
169.                 short v2;
     
170.                 short v3;
     
171.                 unsigned int id;
     
172.                 unsigned int ftlc;
     
173.         };
     
174.         unsigned char buff[16];
     
175.         unsigned char data[16];
     
176.         unsigned short v16[4];
     
177.         
     
178.         CAN_Message(){
     
179.                 DA = 0;
     
180.                 DB = 0;
     
181.                 ID = 0;        
     
182.                 ftlc = 0;
     
183.         }
     
184.         CAN_Message(const CAN_Message& t){
     
185.                 DA = t.DA;
     
186.                 DB = t.DB;
     
187.                 ID = t.ID;
     
188.                 ftlc = t.ftlc;
     
189.         }
     
190.         CAN_Message& operator=(const CAN_Message& t){
     
191.                 DA = t.DA;
     
192.                 DB = t.DB;
     
193.                 ID = t.ID;
     
194.                 ftlc = t.ftlc;
     
195.                 return *this;
     
196.         }
     
197. };
     
198. #pragma pop
     
199. 
     
200. // 使用例子
     
201. 
     
202. // 定义一个CAN_Message队列,使用自动分配内存,队列能容纳99个CAN_Message
     
203. queue<CAN_Message> CanReceiveQueue(100);
     
204. // 或者
     
205. CAN_Message CanReceiveBuf[100];
     
206. queue<CAN_Message> CanReceiveQueue(CanReceiveBuf,100);
     
207. 
     
208. // 假设这是CAN接收回调函数,一般是在中断调用的
     
209. void CAN_ReceiveCallBack(CAN_Message & msg){
     
210.         if (CanReceiveQueue.CountToWrite()) {
     
211.                 CanReceiveQueue.EnQueue(msg);
     
212.         }
     
213. }
     
214. 
     
215. 
     
216. int main(void){
     
217.         CAN_Message msg1;
     
218.         
     
219.         // 环境初始化...
     
220.         
     
221.         while(true){               
     
222.                 // 打印接收到的CAN报文
     
223.                 if(CanReceiveQueue.CountToRead()){
     
224.                         CanReceiveQueue.DeQueue(msg1);        
     
225.                         printf("from:CAN%l,len=%l,id=%8XL | ",msg1.ctrl,msg1.len,msg1.ID);
     
226.                         for(int i = 0;i < msg1.len;i++){
     
227.                                 printf("%'02XL,",msg1.buff[i]);
     
228.                         }               
     
229.                         printf("\n");               
     
230.         }
     
231. }
     
232. 
     
233. 
     
234. /*
     
235. note:
     
236.         对于复杂数据类型,一定要实现[拷贝构造函数]与[operator=运算符]才能放入queue.
     
237.         其它数据类型如int,short,char可随便使用
     
238.          如: queue<int> q1;
     
239.              q1.Init(count);
     
240. 
     
241.         关于线程安全性:
     
242.         使用queue时,必须要考虑线程安全性,如:中断与任务,任务与任务之间.
     
243.         当在中断中入队时,不要有其它地方也做入队操作,出队也是同理
     
244.         入队操作与出队操作之间不存在线程安全问题!
     
245.         当有多个任务需要对队列做相同操作时,请封装queue,并使用mutex,此处略
     
246. 
     
247. 另外,有些人把queue与RTOS绑在一起,搞的好像RTOS好厉害的样子,简直误人子弟!
     
248. */
     
249. 
     

复制代码

bobde163

C++的不懂，我一般用来作通信的FIFO

samos2011

uart的发送与接收，can，tcp/ip协议栈，等等，都离不开queue

247153481

楼主既然写了，不如把线程安全的无锁队列也写一下，还有多对多的cas，不知道arm里米有这样的指令

yejibin1977

楼主，辛苦了