【C++】C++模板实现的单向队列

0x55AA

C++模板实现的单向队列的元素添加，元素删除，元素清除功能
Queues.h

1. //Queues.h
   
2. #ifndef DDXX_QUEUES_H
   
3. #define DDXX_QUEUES_H
   
4. #include <iostream>
   
5. using namespace std;
   
6. 
   
7. template<typename Type>
   
8. class Queues
   
9. {
   
10. public:
    
11.         Queues();
    
12.         ~Queues();
    
13. public:
    
14.         struct Node
    
15.         {
    
16.                 Type        e;
    
17.                 Node*        next;
    
18.                
    
19.                 Node()
    
20.                 {
    
21.                 }
    
22.                 Node(Type _e)
    
23.                 {
    
24.                         e                = _e;
    
25.                         next        = NULL;
    
26.                 }
    
27.         };
    
28. public:
    
29.         bool add(Type e);
    
30.         bool erase();
    
31.         bool isEmpty();
    
32.         int  getLength();
    
33.         void print();
    
34.         void clear();
    
35. private:
    
36.         int                m_Length;
    
37.         Node*        m_head;
    
38.         Node*        m_end;
    
39. };
    
40. 
    
41. template<typename Type> Queues<Type>::Queues()
    
42. {
    
43.         m_head = new Node;
    
44.         m_end = m_head;
    
45.         m_head->next = NULL;
    
46.         m_Length = 0;
    
47. }
    
48. 
    
49. // here change Type to Types has no influence to "add" function
    
50. template<typename Types> bool Queues<Types>::add(Types e)
    
51. {
    
52.         Node* ptr = new Node(e);
    
53.         if( ptr == NULL )
    
54.         {
    
55.                 cout<<"Allocate memory for new element failed"<<endl;
    
56.                 return false;
    
57.         }
    
58.         m_end->next = ptr;
    
59.         m_end = ptr;
    
60. 
    
61.         m_Length++;
    
62.         return true;
    
63. }
    
64. 
    
65. template<typename Type> bool Queues<Type>::erase()
    
66. {
    
67.         if ( m_head->next == NULL )
    
68.         {
    
69.                 cout<<"The queue is empty"<<endl;
    
70.                 return false;
    
71.         }
    
72.         Node* ptr = m_head->next;
    
73.         m_head->next = ptr->next;
    
74.         delete ptr;
    
75.         ptr = NULL;
    
76. 
    
77.         m_Length--;
    
78.         return true;
    
79. }
    
80. 
    
81. template<typename Types> bool Queues<Types>::isEmpty()
    
82. {
    
83.         return m_head == m_end;
    
84. }
    
85. template<typename Type> int Queues<Type>::getLength()
    
86. {
    
87.         return m_Length;
    
88. }
    
89. 
    
90. template<typename Type> void Queues<Type>::print()
    
91. {
    
92.         Node* ptr = m_head;
    
93.         while(ptr->next != NULL)
    
94.         {
    
95.                 ptr = ptr->next;
    
96.                 cout<<"element value:"<<ptr->e<<endl;
    
97.         }
    
98. }
    
99. 
    
100. template<typename Type> void Queues<Type>::clear()
     
101. {
     
102.         Node* ptr = m_head->next;
     
103.         while(ptr != NULL)
     
104.         {
     
105.                 ptr = ptr->next;
     
106.                 delete m_head->next;
     
107.                 m_head->next = ptr;
     
108.                 m_Length--;
     
109.         }
     
110.         m_end = m_head;
     
111. }
     
112. 
     
113. template<typename Type> Queues<Type>::~Queues()
     
114. {
     
115.         Node* ptr = m_head->next;
     
116.         while(ptr != NULL)
     
117.         {
     
118.                 ptr = ptr->next;
     
119.                 delete m_head->next;
     
120.                 m_head->next = ptr;
     
121.                 m_Length--;
     
122.         }
     
123.         m_end = m_head;
     
124.         delete m_head;
     
125.         m_head = NULL;
     
126.         m_end = NULL;
     
127. }
     
128. #endif

复制代码

main.cpp

1. // main.cpp
   
2. #include <iostream>
   
3. #include "Queues.h"
   
4. using namespace std;
   
5. 
   
6. void main()
   
7. {
   
8.         cout<<"*****************************test queue init***************************"<<endl;
   
9.         Queues<int> Que;
   
10.         cout<<"Queues is empty? :"<<Que.isEmpty()<<endl;
    
11.         cout<<"Que's length is:"<<Que.getLength()<<endl;
    
12. 
    
13.         cout<<"*****************************test queue add****************************"<<endl;
    
14.         Que.add(1);
    
15.         Que.add(2);
    
16.         Que.add(3);
    
17.         Que.add(4);
    
18.         Que.print();
    
19.         cout<<"Queues is empty? :"<<Que.isEmpty()<<endl;
    
20.         cout<<"Que's length is:"<<Que.getLength()<<endl;
    
21. 
    
22.         cout<<"*****************************test queue erase**************************"<<endl;
    
23.         Que.erase();
    
24.         Que.erase();
    
25.         Que.print();
    
26.         cout<<"Queues is empty? :"<<Que.isEmpty()<<endl;
    
27.         cout<<"Que's length is:"<<Que.getLength()<<endl;
    
28. 
    
29.         cout<<"*****************************test queue clear**************************"<<endl;
    
30.         Que.clear();
    
31.         Que.print();
    
32.         cout<<"Queues is empty? :"<<Que.isEmpty()<<endl;
    
33.         cout<<"Que's length is:"<<Que.getLength()<<endl;
    
34. }

复制代码

程序的运行结果：