思考：
使用智能指针替换单链表LinkLIst中的原生指针是否可行？
将LinkList.h中的Node指针全部改成智能指针：
1 #ifndef LINKLIST_H
2 #define LINKLIST_H
3
4 #include "List.h"
5 #include "Exception.h"
6 #include "SmartPointer.h"
7
8 namespace DTLib
9 {
10
11 template < typename T >
12 class LinkList : public List<T>
13 {
14 protected:
15 struct Node : public Object
16 {
17 T value;
18 SmartPointer<Node> next;
19 };
20
21 mutable struct : public Object
22 {
23 char reserved[sizeof(T)];
24 SmartPointer<Node> next;
25 }m_header;
26
27 int m_length;
28 int m_step;
29 SmartPointer<Node> m_current;
30
31 Node* position(int i) const // O(n)
32 {
33 //Node* ret = reinterpret_cast<Node*>(&m_header);
34 SmartPointer<Node> ret = reinterpret_cast<Node*>(&m_header);
35
36 for(int p = 0; p < i; p++)
37 {
38 ret = ret->next;
39 }
40
41 return ret.get();
42 }
43
44 virtual Node* create()
45 {
46 return new Node();
47 }
48
49 virtual void destroy(Node* pn)
50 {
51 delete pn;
52 }
53
54 public:
55 LinkList()
56 {
57 m_header.next = NULL;
58 m_length = 0;
59 m_step = 1;
60 m_current = NULL;
61 }
62
63 bool insert(const T& e)
64 {
65 return insert(m_length, e);
66 }
67
68 bool insert(int i, const T& e) // O(n)
69 {
70 bool ret = ((0 <= i) && (i <= m_length));
71
72 if( ret )
73 {
74 Node* node = create();
75
76 if( node != NULL )
77 {
78 Node* current = position(i);
79
80 node->value = e;
81 node->next = current->next;
82 current->next = node;
83
84 m_length++;
85 }
86 else
87 {
88 THROW_EXCEPTION(NoEnoughMemoryException, "No memery to insert new element...");
89 }
90 }
91
92 return ret;
93 }
94
95 bool remove(int i) // O(n)
96 {
97 bool ret = ((0 <= i) && (i < m_length));
98
99 if( ret )
100 {
101 SmartPointer<Node> current = position(i);
102
103 SmartPointer<Node> toDel = current->next;
104
105 if( m_current == toDel )
106 {
107 m_current = toDel->next;
108 }
109
110 current->next = toDel->next;
111
112 m_length--;
113
114 // destroy(toDel);
115
116 }
117
118 return ret;
119 }
120
121 bool set(int i, const T& e) // O(n)
122 {
123 bool ret = ((0 <= i) && (i < m_length));
124
125 if( ret )
126 {
127 position(i)->next->value = e;
128 }
129
130 return ret;
131 }
132
133 T get(int i) const
134 {
135 T ret;
136
137 if( get(i, ret) )
138 {
139 return ret;
140 }
141 else
142 {
143 THROW_EXCEPTION(IndexOutOfBoundsException, "Invalid parameter i to get element ...");
144 }
145
146 return ret;
147 }
148
149 bool get(int i, T& e) const // O(n)
150 {
151 bool ret = ((0 <= i) && (i < m_length));
152
153 if( ret )
154 {
155 e = position(i)->next->value;
156 }
157
158 return ret;
159 }
160
161 int find(const T& e) const // O(n)
162 {
163 int ret = -1;
164 int i = 0;
165
166 SmartPointer<Node> node = m_header.next;
167
168 //while( node )
169 while( node.isNull() )
170 {
171 if( node->value == e )
172 {
173 ret = i;
174 break;
175 }
176 else
177 {
178 node = node->next;
179 i++;
180 }
181 }
182
183 return ret;
184 }
185
186 int length() const // O(1)
187 {
188 return m_length;
189 }
190
191 void clear() // O(n)
192 {
193 //while( m_header.next )
194 while( m_header.next.isNull() )
195 {
196 //Node* toDel = m_header.next;
197 SmartPointer<Node> toDel = m_header.next;
198
199 m_header.next = toDel->next;
200
201 m_length--;
202
203 // destroy(toDel);
204 }
205
206 // m_length = 0;
207 }
208
209 bool move(int i, int step = 1)
210 {
211 bool ret = (0 <= i) && (i < m_length) && (step > 0);
212
213 if( ret )
214 {
215 m_current = position(i)->next;
216 m_step = step;
217 }
218
219 return ret;
220 }
221
222 bool end()
223 {
224 //return (m_current == NULL);
225 return m_current.isNull();
226 }
227
228 T current()
229 {
230 if( !end() )
231 {
232 return m_current->value;
233 }
234 else
235 {
236 THROW_EXCEPTION(InvalidOperationException, "No value at current position ...");
237 }
238 }
239
240 bool next() //每次移动step步
241 {
242 int i = 0;
243
244 while((i < m_step) && !end())
245 {
246 m_current = m_current->next;
247 i++;
248 }
249
250 return (i == m_step);
251 }
252
253 ~LinkList() // O(n)
254 {
255 clear();
256 }
257 };
258
259 }
260
261 #endif // LINKLIST_H
测试程序如下：
1 #include <iostream>
2 #include "LinkList.h"
3
4 using namespace std;
5 using namespace DTLib;
6
7
8 int main()
9 {
10 LinkList<int> list;
11
12 for(int i = 0; i < list.length(); i++)
13 {
14 list.insert(i);
15 }
16
17 for(list.move(0); !list.end(); list.next())
18 {
19 cout << list.current() << endl;
20 }
21
22 return 0;
23 }
运行结果如下：
程序直接崩溃了。
我们的SmartPointer设计中，一片堆空间最多只能由一个指针标识，但是我们设计的和遍历有关的函数，例如move、end、current、next，在遍历时一片堆空间会由多个指针指向，所以程序崩溃了。
改进方案：
我们需要创建一个中间类pointer，并且它还有两个子类。
SharedPointer支持一片堆空间由多个指针指向，也支持自动释放。
在设计上做了改动，所以SmartPointer也得做改动。
pointer类中的析构函数是纯虚函数，因为pointer是一个抽象父类，需要由子类继承才能生成对象。
Object的析构函数就是纯虚的，所以pointer中就没有必要再写一遍了。
只要pointer没有实现自己的析构函数，那么它就还是一个抽象类。
原文地址：https://www.cnblogs.com/wanmeishenghuo/p/9652199.html
时间： 2024-10-29 19:05:42