C/C++ 的使用

C++    http://www.cplusplus.com/

http://www.cplusplus.me/

*****************容器container vector

转自 http://blog.csdn.net/qscool1987/article/details/7050487

[cpp] view plaincopy

1. #ifndef _MY_VECTOR_H
2. #define _MY_VECTOR_H
3. #include <string.h>
4. #include <assert.h>
5. template<class T>
6. class MyVector
7. {
8. public:
9. class iterator
10. {
11. public:
12. iterator():pelem(NULL){}
13. iterator(T *pt):pelem(pt){}
14. iterator(const iterator &iter);
15. iterator& operator = (const iterator &iter);
16. iterator& operator = (T *pt);
17. ~iterator(){}
18. bool operator != (const iterator &iter);
19. iterator& operator ++ ();
20. iterator& operator ++ (int);
21. iterator& operator -- ();
22. iterator& operator -- (int);
23. iterator  operator + (size_t size);
24. iterator  operator - (size_t size);
25. iterator& operator -= (size_t size);
26. iterator& operator += (size_t size);
27. T& operator * ();
28. //functions add here
29. private:
30. T *pelem;
31. };
32. //constructor
33. MyVector():pbuff(NULL),beg(NULL),last(NULL),count(0),capcity(0){}
34. MyVector(const MyVector &orig);
35. MyVector& operator = (const MyVector &orig);
36. ~MyVector();
37. //member function
38. T& operator [] (size_t index);
39. void pushback(const T &mt);
40. iterator insert(size_t index,const T &mt);
41. iterator insert(const T *phead,const T *pback, iterator p);
42. iterator erase(size_t index);
43. iterator erase(iterator phead, iterator pback);
44. void clear();
45. size_t size();
46. size_t capacity();
47. iterator begin();
48. iterator end();
49. private:
50. void del_buff()
51. {
52. if(NULL != pbuff)
53. {
54. delete pbuff;
55. pbuff = NULL;
56. }
57. }
58. T *pbuff;//Memory buff for elements
59. iterator beg;
60. iterator last;
61. size_t count;
62. size_t capcity;
63. };
64. /**MyVector‘s member functions**/
65. /**here are the member functions implementations**/
66. template<class T>
67. size_t MyVector<T>::size()
68. {
69. return count;
70. }
71. template<class T>
72. size_t MyVector<T>::capacity()
73. {
74. return capcity;
75. }
76. template<class T>
77. MyVector<T>::MyVector(const MyVector<T> &orig)
78. {
79. count = orig.size();
80. capcity = 2*count;
81. pbuff = new T [count*2];
82. size_t totalbytes = count*2*sizeof(T);
83. memcpy(pbuff,orig.pbuff,totalbytes);
84. }
85. template<class T>
86. MyVector<T>& MyVector<T>::operator = (const MyVector<T> &orig)
87. {
88. del_buff();
89. count = orig.size();
90. capcity = 2*count;
91. pbuff = new T [count*2];
92. size_t totalbytes = count*2*sizeof(T);
93. memcpy(pbuff,orig.pbuff,totalbytes);
94. return *this;
95. }
96. template<class T>
97. MyVector<T>::~MyVector<T>()
98. {
99. del_buff();
100. }
101. template<class T>
102. T& MyVector<T>::operator[](size_t index)
103. {
104. return pbuff[index];
105. }
106. template<class T>
107. void MyVector<T>::pushback(const T &mt)
108. {
109. if(NULL == pbuff && 0 == count)
110. {
111. pbuff = new T[(1+count)*2];
112. pbuff[0] = mt;
113. count++;
114. capcity = 2*count;
115. }
116. else
117. {
118. if(NULL != pbuff && count == capcity)
119. {
120. capcity *= 2;
121. T *ptem = new T[capcity];
122. size_t totalbytes = capcity*sizeof(T);
123. memcpy(ptem,pbuff,totalbytes);
124. del_buff();
125. pbuff = ptem;
126. pbuff[count] = mt;
127. count ++;
128. }
129. if(NULL != pbuff && count != capcity)
130. {
131. pbuff[count] = mt;
132. count++;
133. }
134. }
135. }
136. template<class T>
137. typename MyVector<T>::iterator MyVector<T>::insert(size_t index,const T &mt)
138. {
139. assert(count >= index);
140. if(NULL != pbuff && count == capcity)
141. {
142. capcity *= 2;
143. T *ptem = new T[capcity];
144. memcpy(ptem,pbuff,capcity*sizeof(T));
145. ptem[index] = mt;
146. memcpy(&ptem[index+1],(count-index)*sizeof(T));
147. del_buff();
148. pbuff = ptem;
149. count ++;
150. typename MyVector<T>::iterator _iter(&pbuff[index]);
151. return _iter;
152. }
153. else if(NULL != pbuff && count != capcity)
154. {
155. size_t _end = count-1;
156. size_t _beg = index;
157. for(;_end >= _beg;_end--)
158. pbuff[_end+1] = pbuff[_end];
159. pbuff[index] = mt;
160. count++;
161. typename MyVector<T>::iterator _iter(&pbuff[index]);
162. return _iter;
163. }
164. }
165. template<class T>
166. typename MyVector<T>::iterator MyVector<T>::
167. insert(const T *phead,const T *pback,
168. typename MyVector<T>::iterator p)
169. {
170. typename MyVector<T>::iterator _beg = begin(),_end = end();
171. size_t insertnum = 0;
172. for(;phead != pback;phead++)
173. insertnum++;
174. phead -= insertnum;
175. size_t index = 0;
176. for(;_beg != p;_beg++)
177. index++;
178. if(count +insertnum > capcity && NULL != pbuff)
179. {
180. capcity = 2*(count +insertnum);
181. T *ptem = new T [capcity];
182. memcpy(ptem,pbuff,(index)*sizeof(T));
183. memcpy(&ptem[index],phead,insertnum*sizeof(T));
184. memcpy(&ptem[index+insertnum],&pbuff[index],
185. (count-index)*sizeof(T));
186. del_buff();
187. pbuff = ptem;
188. count += insertnum;
189. typename MyVector<T>::iterator _iter(&pbuff[index]);
190. return _iter;
191. }
192. else if(count +insertnum <= capcity && NULL != pbuff)
193. {
194. for(size_t i = insertnum;i != 0;i--,count--)
195. pbuff[count+insertnum-1] = pbuff[count-1];
196. for(;phead != pback;phead++,p++)
197. *p = *phead;
198. count += insertnum;
199. return p;
200. }
201. if(NULL == pbuff && 0 == count)
202. {
203. capcity = 2*insertnum;
204. pbuff = new T[capcity];
205. memcpy(pbuff,phead,insertnum*sizeof(T));
206. count = insertnum;
207. typename MyVector<T>::iterator _iter(&pbuff[0]);
208. return _iter;
209. }
210. }
211. template<class T>
212. typename MyVector<T>::iterator MyVector<T>::erase(size_t index)
213. {
214. T *temp = new T[count-index-1];
215. memcpy(temp,&pbuff[index+1],(count-index-1)*sizeof(T));
216. memcpy(&pbuff[index],temp,(count-index-1)*sizeof(T));
217. pbuff[count-1] = ‘\0‘;
218. count--;
219. delete [] temp;
220. typename MyVector<T>::iterator _iter(&pbuff[index]);
221. return _iter;
222. }
223. template<class T>
224. typename MyVector<T>::iterator MyVector<T>::
225. erase( typename MyVector<T>::iterator phead,
226. typename MyVector<T>::iterator pback)
227. {
228. size_t elemnum = 0;
229. size_t _toend = 0;
230. for(;phead != pback;phead++)
231. elemnum++;
232. phead -= elemnum;
233. for(;pback != end();pback++)
234. _toend++;
235. pback -= _toend;
236. T *temp = new T[_toend];
237. memcpy(temp,&pbuff[count-_toend],_toend*sizeof(T));
238. memcpy(&pbuff[count-elemnum-_toend],temp,_toend*sizeof(T));
239. memset(&pbuff[count-elemnum],‘\0‘,(count-elemnum)*sizeof(T));
240. delete [] temp;
241. count -= elemnum;
242. return phead;
243. }
244. template<class T>
245. typename MyVector<T>::iterator MyVector<T>::begin()
246. {
247. beg = &pbuff[0];
248. return beg;
249. }
250. template<class T>
251. typename MyVector<T>::iterator MyVector<T>::end()
252. {
253. last = &pbuff[count];
254. return last;
255. }
256. /**nested dependent typeclass**/
257. /**implementation**/
258. template<class T>
259. MyVector<T>::iterator::iterator(const typename MyVector<T>::iterator &iter)
260. {
261. pelem = iter.pelem;
262. }
263. template<class T>
264. typename MyVector<T>::iterator& MyVector<T>::iterator::
265. operator = (const typename MyVector<T>::iterator &iter)
266. {
267. pelem = iter.pelem;
268. return *this;
269. }
270. template<class T>
271. typename MyVector<T>::iterator& MyVector<T>::iterator::
272. operator = (T *pt)
273. {
274. pelem = pt;
275. return *this;
276. }
277. template<class T>
278. bool MyVector<T>::iterator::operator !=
279. (const typename MyVector<T>::iterator &iter)
280. {
281. if(pelem != iter.pelem)
282. return true;
283. else
284. return false;
285. }
286. template<class T>
287. typename MyVector<T>::iterator& MyVector<T>::iterator::operator ++ ()
288. {
289. ++pelem;
290. return *this;
291. }
292. template<class T>
293. typename MyVector<T>::iterator& MyVector<T>::iterator::operator ++ (int)
294. {
295. pelem++;
296. return *this;
297. }
298. template<class T>
299. typename MyVector<T>::iterator& MyVector<T>::iterator::operator -- (int)
300. {
301. pelem--;
302. return *this;
303. }
304. template<class T>
305. typename MyVector<T>::iterator& MyVector<T>::iterator::operator -- ()
306. {
307. --pelem;
308. return *this;
309. }
310. template<class T>
311. typename MyVector<T>::iterator& MyVector<T>::iterator::operator += (size_t size)
312. {
313. pelem += size;
314. return *this;
315. }
316. template<class T>
317. typename MyVector<T>::iterator& MyVector<T>::iterator::operator -= (size_t size)
318. {
319. pelem -= size;
320. return *this;
321. }
322. template<class T>
323. typename MyVector<T>::iterator MyVector<T>::iterator::operator + (size_t size)
324. {
325. pelem += size;
326. typename MyVector<T>::iterator _iter(pelem);
327. return _iter;
328. }
329. template<class T>
330. typename MyVector<T>::iterator MyVector<T>::iterator::operator - (size_t size)
331. {
332. pelem -= size;
333. typename MyVector<T>::iterator _iter(pelem);
334. return _iter;
335. }
336. template<class T>
337. T& MyVector<T>::iterator::operator * ()
338. {
339. return *pelem;
340. }
341. #endif