//代码功能除insert不完善，其余均可正确输出。
1 #include <iostream>
2 #include<vector>
3 #include<cstring>
4 using namespace std;
5 /* run this program using the console pauser or add your own getch, system("pause") or input loop */
6
7 template <class T>
8 class CMyVector{
9 T *pBuff;
10 size_t maxSize; //容器最大容量
11 size_t len; //容器元素个数
12 public:
13 struct MyIterator{ //迭代器
14 T *pIt;
15 //*************重载运算符******************
16 T operator*(){
17 return *pIt;
18 }
19 MyIterator& operator=(MyIterator const& srcIt){
20 pIt = srcIt.pIt;
21 return *this;
22 }
23 MyIterator operator+(int n)const{
24 MyIterator it;
25 it.pIt = pIt;
26 it.pIt += n;
27 return it;
28 }
29 MyIterator operator-(int n)const{
30 MyIterator it;
31 it.pIt = pIt;
32 it.pIt -= n;
33 return it;
34 }
35 MyIterator& operator++(){
36 pIt++;
37 return *this;
38 }
39 bool operator != (MyIterator const& srcIt) const{
40 return pIt != srcIt.pIt;
41 }
42 size_t operator-(MyIterator const& srcIt) const{
43 return pIt - srcIt.pIt;
44 }
45 };
46 MyIterator end(){//末尾位置
47 MyIterator it;
48 it.pIt = pBuff + len;
49 return it;
50 }
51 MyIterator begin(){//开始位置
52 MyIterator it;
53 it.pIt = pBuff;
54 return it;
55 }
56 //*****************构造函数********************
57 CMyVector(int n, T const& val);//用val生成大小为n的容器
58 CMyVector(int n);//生成大小为n的容器，元素值为默认值
59 CMyVector(CMyVector const& other);//拷贝构造
60 CMyVector(MyIterator first, MyIterator second);
61 CMyVector();
62 ~CMyVector();
63 void clear();
64
65 size_t size() const;//返回当前元素的数量
66 bool empty() const;//返回容器是否为空
67 size_t capacity()const;//返回重新分配空间之前最大容器大小
68 //*****************************重载运算符**************************
69 bool operator==(CMyVector const& srcVector) const;
70 bool operator!=(CMyVector const& srcVector) const;
71 bool operator<(CMyVector const& srcVector) const;
72 bool operator<=(CMyVector const& srcVector) const;
73 bool operator>(CMyVector const& srcVector) const;
74 bool operator>=(CMyVector const& srcVector) const;
75 bool operator=(CMyVector const& srcVector) const;
76
77 //只能定义在类内，类外定义有特定语法，删除迭代器之间的元素
78 MyIterator erase(MyIterator const& first, MyIterator const& last){
79 int index1 = first.pIt - pBuff;
80 int index2 = last.pIt - pBuff;
81 for(int i = index1, j = index2; j < len; ++i, ++j){
82 pBuff[i] = pBuff[j];
83 }
84 len = len - index2 + index1;
85 MyIterator it;
86 it.pIt = pBuff + index1;
87 return it;
88 }
89 //只能定义在类内，类外定义有特定语法，删除迭代器位置的元素
90 MyIterator erase(MyIterator const& pos){
91 int index = pos.pIt - pBuff;
92 for(int i = index; i < len - 1; ++i){
93 pBuff[i] = pBuff[i + 1];
94 }
95 len--;
96 MyIterator it;
97 it.pIt = pBuff + index;
98 return it;
99 }
100 //在pos位置以后插入first与last之间的所有元素
101 void insert(MyIterator const& pos, MyIterator const& first, MyIterator const& last);
102 //在pos位置以后插入n个val
103 void insert(MyIterator const& pos, int n, T const& val);
104 //只能定义在类内，在pos位置插入val
105 MyIterator insert(MyIterator const& pos, T const& val){
106 int index = pos.pIt - pBuff;
107 if(len >= maxSize){
108 maxSize = maxSize + ((maxSize >> 1) > 1 ? (maxSize >> 1) : 1);
109 T *tempBuff = new T[maxSize];
110 memcpy(tempBuff, pBuff, sizeof(T)* len);
111 if(pBuff) delete[] pBuff;
112 pBuff = tempBuff;
113 }
114 for(int i = len - 1; i >= index; --i){
115 pBuff[i + 1] = pBuff[i];
116 }
117 pBuff[index] = val;
118 len++;
119 MyIterator it;
120 it.pIt = pBuff + index;
121 return it;
122 }
123 void assign(int n, T const& val);//清除容器并赋值为n个val
124 void assign(MyIterator first, MyIterator last);//清除容器并将first到last之间的所有元素赋值给容器
125 void swap(CMyVector& srcVector);//交换两容器
126 T at(int index);//返回index位置处的元素,这个函数是为数不多异常处理的函数
127 T operator[](int index);//返回index位置处的元素，不检查元素是否存在
128 T front();//返回第1个元素位置，不检查元素是否存在
129 T back();//返回最后1个元素位置，不检查元素是否存在
130 void push_back(T const& val);//在尾部添加val
131 void pop_back();//在尾部删除元素
132 void resize(int n);//将元素的数量改为n个，如果len<n，多出的新元素用默认构造
133 };
134 template<class T>
135 void CMyVector<T>::resize(int n){
136 if(n > maxSize){
137 maxSize = n;
138 T *tempBuff = new T[maxSize];
139 memcpy(tempBuff, pBuff, sizeof(T)* len);
140 if(pBuff) delete[] pBuff;
141 pBuff = tempBuff;
142 memset(pBuff + len, 0, sizeof(T) * (n - len));
143 }
144 maxSize = len = n;
145 }
146 template<class T>
147 void CMyVector<T>::pop_back(){
148 len--;
149 }
150 template<class T>
151 void CMyVector<T>::push_back(T const& val){
152 if(len >= maxSize){
153 maxSize = maxSize + ((maxSize >> 1) > 1 ? (maxSize >> 1) : 1);
154 T *tempBuff = new T[maxSize];
155 memcpy(tempBuff, pBuff, sizeof(T)* len);
156 if(pBuff) delete[] pBuff;
157 pBuff = tempBuff;
158 }
159 pBuff[len++] = val;
160 }
161 template<class T>
162 T CMyVector<T>::back(){
163 return pBuff[len - 1];
164 }
165 template<class T>
166 T CMyVector<T>::front(){
167 return pBuff[0];
168 }
169 template<class T>
170 T CMyVector<T>::operator[](int index){
171 return pBuff[index];
172 }
173 template<class T>
174 T CMyVector<T>::at(int index){
175 if(index < 0 || index >= len) throw "range_out";//抛异常
176 return pBuff[index];
177 }
178 template<class T>
179 void CMyVector<T>::swap(CMyVector& srcVector){
180 T *tempBuff = pBuff;
181 size_t templen = len;
182 size_t tempMaxSize = maxSize;
183
184 pBuff = srcVector.pBuff;
185 len = srcVector.len;
186 maxSize = srcVector.maxSize;
187
188 srcVector.pBuff = tempBuff;
189 srcVector.len = templen;
190 srcVector.maxSize = tempMaxSize;
191 }
192 template<class T>
193 void CMyVector<T>::assign(MyIterator first, MyIterator last){
194 clear();
195 maxSize = len = last.pIt - first.pIt + 1;
196 pBuff = new T[len];
197 for(int i = 0; i < len; ++i){
198 pBuff[i] = *(first + i);
199 }
200 }
201 template<class T>
202 void CMyVector<T>::assign(int n, T const& val){
203 clear();
204 len = maxSize = n;
205 pBuff = new T[len];
206 for(int i = 0; i < len; ++i)
207 {
208 pBuff[i] = val;
209 }
210 }
211 template<class T>
212 void CMyVector<T>::insert(MyIterator const& pos, int n, T const& val){
213 int index = pos.pIt - pBuff;
214 if((len + n) > maxSize){
215 maxSize += n;
216 T *tempBuff;
217 tempBuff = new T[maxSize];
218 memcpy(tempBuff, pBuff, sizeof(T)* len);
219 if(pBuff) delete[] pBuff;
220 pBuff = tempBuff;
221 }
222 for(int j = 0; j < n; ++j){
223 for(int i = len - 1 + j; i >= index + j; --i){
224 pBuff[i + 1] = pBuff[i];
225 }
226 }
227 for(int i = 0; i < n; ++i){
228 pBuff[index + i] = val;
229 }
230 }
231 template<class T>
232 void CMyVector<T>::insert(MyIterator const& pos, MyIterator const& first, MyIterator const& last){
233 int index1 = pos.pIt - pBuff;
234 int index2 = last.pIt - first.pIt;
235 for(int i = 0; i < index2; ++i){
236 for(int j = len - 1 + i; j >= index1 + i; --j){
237 pBuff[j + 1] = pBuff[j];
238 }
239 }
240 for(int i = 0; i < index2; ++i){
241 pBuff[index1 + i] = *(first + i);
242 }
243
244 }
245
246 template <class T>
247 bool CMyVector<T>::operator=(CMyVector const& srcVector) const
248 {
249 clear();
250 len = srcVector.len;
251 maxSize = srcVector.maxSize;
252 if(srcVector.pBuff){
253 pBuff = srcVector;
254 return true;
255 }
256 return false;
257 }
258 template <class T>
259 bool CMyVector<T>::operator>=(CMyVector const& srcVector) const
260 {
261 return (*this > srcVector) || (*this == srcVector);
262 }
263 template<class T>
264 bool CMyVector<T>::operator>(CMyVector const& srcVector)const{
265 if(len == 0 || srcVector.len == 0) return false;
266 int tempLen = (len < srcVector.len) ? len : srcVector.len;
267 for(int i = 0; i < tempLen; ++i){
268 if(pBuff[i] > srcVector.pBuff[i]) return true;
269 if(pBuff[i] < srcVector.pBuff[i]) return false;
270 }
271 return false;
272 }
273 template <class T>
274 bool CMyVector<T>::operator<=(CMyVector const& srcVector) const
275 {
276 return (*this < srcVector) || (*this == srcVector);
277 }
278 template<class T>
279 bool CMyVector<T>::operator<(CMyVector const& srcVector)const{
280 if(len == 0 || srcVector.len == 0) return false;
281 int tempLen = (len < srcVector.len) ? len : srcVector.len;
282 for(int i = 0; i < tempLen; ++i){
283 if(pBuff[i] < srcVector.pBuff[i]) return true;
284 if(pBuff[i] > srcVector.pBuff[i]) return false;
285 }
286 return false;
287 }
288 template<class T>
289 bool CMyVector<T>::operator!=(CMyVector const& srcVector)const{
290 return !(*this == srcVector);
291 }
292 template<class T>
293 bool CMyVector<T>::operator==(CMyVector const& srcVector)const{
294 if(len == srcVector.len){
295 for(int i = 0; i < len; ++i){
296 if(pBuff[i] != srcVector.pBuff[i]) return false;
297 }
298 return true;
299 }
300 return false;
301 }
302 template<class T>
303 size_t CMyVector<T>::capacity()const{
304 return maxSize;
305 }
306 template<class T>
307 bool CMyVector<T>::empty()const{
308 return len == 0;
309 }
310 template<class T>
311 size_t CMyVector<T>::size()const{
312 return len;
313 }
314
315 template<class T>
316 void CMyVector<T>::clear(){
317 if(pBuff) delete[] pBuff;
318 pBuff = NULL;
319 maxSize = len = 0;
320 }
321 template<class T>
322 CMyVector<T>::~CMyVector(){
323 clear();
324 }
325 template<class T>
326 CMyVector<T>::CMyVector(){
327 len = maxSize = 0;
328 pBuff = NULL;
329 }
330 template<class T>
331 CMyVector<T>::CMyVector(MyIterator first, MyIterator second){
332 len = maxSize = 0;
333 pBuff = NULL;
334 int n = 0;
335 if((n = second - first) > 0){
336 len = maxSize = n;
337 pBuff = new T[len];
338 for(int i = 0; i < len; ++i){
339 pBuff[i] = *(first + i);
340 }
341 }
342 }
343 template<class T>
344 CMyVector<T>::CMyVector(CMyVector const& other){
345 len = other.len;
346 maxSize = other.maxSize;
347 if(other.pBuff != NULL){
348 pBuff = new T[maxSize];
349 memcpy(pBuff, other.pBuff, sizeof(T) * len);
350 }
351 }
352 template<class T>
353 CMyVector<T>::CMyVector(int n){
354 len = maxSize = n;
355 pBuff = new T[len];
356 memset(pBuff, 0, sizeof(T)* len);
357 }
358 template<class T>
359 CMyVector<T>::CMyVector(int n, T const& val){
360 len = maxSize = n;
361 pBuff = new T[len];
362 for(int i = 0; i < len; ++i)
363 pBuff[i] = val;
364 }
365 int main(int argc, char** argv) {
366 printf("\n=================================MyVector=======================================\n");
367 CMyVector<int> mans;
368 cout << "调用push_back,重载[]：";
369 for(int i = 0; i < 10; ++i){
370 mans.push_back(i + 1); //push_back
371 printf("%d ", mans[i]); //重载[]
372 }
373 CMyVector<int>::MyIterator mtestvit1, mtestvit2;
374 mtestvit1 = mans.begin() + 2;
375 mtestvit2 = mans.begin() + 8;
376 //**************测试insert******************************
377 /* cout << endl << "测试insert：";
378 mans.insert(mtestvit1, 5, 6);
379 for(int i = 0; i < 15; ++i){
380 printf("%d ", mans[i]);
381 }*/
382 /* mans.insert(mtestvit1, mtestvit1 + 2, mtestvit2);
383 for(int i = 0; i < 15; ++i){
384 printf("%d ", mans[i]);
385 }*/
386 //**************测试erase******************************
387 /* cout << endl << "测试erase：";
388 mans.erase(mtestvit1);
389 for(int i = 0; i < 10; ++i){
390 printf("%d ", mans[i]); //重载[]
391 }
392 cout << endl;
393 mans.erase(mtestvit1, mtestvit2 - 1);
394 for(int i = 0; i < 10; ++i){
395 printf("%d ", mans[i]); //重载[]
396 }*/
397 //**************测试empty,capacity,front,back,resize,at******************************
398 /* cout << endl ;
399 if(mans.empty()) cout << "空" << endl;
400 else cout << "非空" << endl;
401 cout << mans.capacity() <<" " << mans.front() << " " << mans.back() << endl;
402 mans.resize(5);
403 for(int i = 0; i < 10; ++i){
404 printf("%d ", mans[i]); //重载[]
405 }
406 cout << endl;
407 mans.resize(10);
408 for(int i = 0; i < 10; ++i){
409 printf("%d ", mans[i]); //重载[]
410 }
411 cout << endl << mans.at(4) << endl;*/
412 //**************测试构造函数,swap******************************
413 /* cout << endl << "测试构造函数1：";
414 CMyVector<int> mtest1(10, 5);
415 CMyVector<int> mtest2(10);
416 CMyVector<int> mtest3(mans);
417 CMyVector<int> mtest4(mtestvit1, mtestvit2);
418 for(int i = 0; i < 10; ++i){
419 printf("%d ", mtest1[i]); //重载[]
420 }
421 cout << endl << "测试构造函数2：";
422 for(int i = 0; i < 10; ++i){
423 printf("%d ", mtest2[i]); //重载[]
424 }
425 cout << endl << "测试构造函数3：";
426 for(int i = 0; i < 10; ++i){
427 printf("%d ", mtest3[i]); //重载[]
428 }
429 cout << endl << "测试构造函数4：";
430 for(int i = 0; i < 6; ++i){
431 printf("%d ", mtest4[i]); //重载[]
432 }
433 cout << endl << "测试swap：";
434 mtest1.swap(mtest2);
435 for(int i = 0; i < 10; ++i){
436 printf("%d ", mtest1[i]); //重载[]
437 }
438 cout << endl;
439 for(int i = 0; i < 10; ++i){
440 printf("%d ", mtest2[i]); //重载[]
441 }*/
442
443 //**************测试迭代器******************************
444 /* cout << endl << "测试迭代器：";
445 CMyVector<int>::MyIterator mvit; //迭代器
446 for(mvit = mans.begin(); mvit != mans.end(); ++mvit){
447 printf("%d ", *(mvit));
448 } */
449 //***************测试pop_back, size**********************
450 /* mans.pop_back();
451 cout << endl << "调用size,pop_back：";
452 for(int i = 0; i < mans.size(); ++i){
453 printf("%d ", mans[i]);
454 }*/
455 printf("\n==================================vector========================================\n");
456 vector<int> ans;
457 cout << "调用push_back,重载[]：";
458 for(int i = 0; i < 10; ++i){
459 ans.push_back(i + 1);
460 printf("%d ", ans[i]);
461 }
462 vector<int>::iterator testvit1, testvit2;
463 testvit1 = ans.begin() + 2;
464 testvit2 = ans.begin() + 8;
465 //**************测试insert******************************
466 /* cout << endl << "测试insert：";
467 ans.insert(testvit1, 5, 6);
468 for(int i = 0; i < 15; ++i){
469 printf("%d ", ans[i]);
470 }
471 cout << endl;*/
472 /* ans.insert(testvit1, testvit1 + 2, testvit2);
473 for(int i = 0; i < 15; ++i){
474 printf("%d ", ans[i]);
475 }*/
476 //**************测试erase******************************
477 /* cout << endl << "测试erase：";
478 ans.erase(testvit1);
479 for(int i = 0; i < 10; ++i){
480 printf("%d ", ans[i]); //重载[]
481 }
482 cout << endl;
483 ans.erase(testvit1, testvit2 - 1);
484 for(int i = 0; i < 10; ++i){
485 printf("%d ", ans[i]); //重载[]
486 }*/
487 //**************测试empty,capacity,front,back,resize,at******************************
488 /* cout << endl ;
489 if(ans.empty()) cout << "空" << endl;
490 else cout << "非空" << endl;
491 cout << ans.capacity() <<" " << ans.front() << " " << ans.back() << endl;
492 ans.resize(5);
493 for(int i = 0; i < 10; ++i){
494 printf("%d ", ans[i]); //重载[]
495 }
496 cout << endl;
497 ans.resize(10);
498 for(int i = 0; i < 10; ++i){
499 printf("%d ", ans[i]); //重载[]
500 }
501 cout << endl << ans.at(4) << endl;*/
502 //**************测试构造函数,swap******************************
503 /* cout << endl << "测试构造函数1：";
504 vector<int> test1(10, 5);
505 vector<int> test2(10);
506 vector<int> test3(ans);
507 vector<int> test4(testvit1, testvit2);
508 for(int i = 0; i < 10; ++i){
509 printf("%d ", test1[i]); //重载[]
510 }
511 cout << endl << "测试构造函数2：";
512 for(int i = 0; i < 10; ++i){
513 printf("%d ", test2[i]); //重载[]
514 }
515 cout << endl << "测试构造函数3：";
516 for(int i = 0; i < 10; ++i){
517 printf("%d ", test3[i]); //重载[]
518 }
519 cout << endl << "测试构造函数4：";
520 for(int i = 0; i < 6; ++i){
521 printf("%d ", test4[i]); //重载[]
522 }
523 cout << endl << "测试swap：";
524 test1.swap(test2);
525 for(int i = 0; i < 10; ++i){
526 printf("%d ", test1[i]); //重载[]
527 }
528 cout << endl;
529 for(int i = 0; i < 10; ++i){
530 printf("%d ", test2[i]); //重载[]
531 }*/
532 //**************测试迭代器******************************
533 /* cout << endl << "测试迭代器：";
534 vector<int>::iterator vit; //迭代器
535 for(vit = ans.begin(); vit != ans.end(); ++vit){
536 printf("%d ", *(vit));
537 } */
538 //***************测试pop_back, size**********************
539 /* ans.pop_back();
540 cout << endl << "调用size,pop_back：";
541 for(int i = 0; i < ans.size(); ++i){
542 printf("%d ", ans[i]);
543 }*/
544 return 0;
545 }
