Vector重写

1. #ifndef _vec_h
2. #define _vec_h
3. ​
4. #include<memory>
5. #include<algorithm>
6. //#include<cstddef>
7. ​
8. template<class T> class Vec{
9. public:
10. typedef T* iterator;
11. typedef const T* const_iterator;
12. typedef size_t size_type;
13. ​
14.     Vec() {create();    }
15. explicit Vec(size_type n,const T& t=T()) {create(n,t);}
16.     Vec(const Vec& v) {create(v.begin(),v.end());}   //复制构造函数跟构造函数一样，没有返回值
17.     Vec& operator=(const Vec&);       //类外定义
18.     ~Vec() {uncreate();}
19. ​
20.     T& operator {return datai;}
21. const T& operatorconst {return datai;}
22. ​
23.     iterator begin() {return data;  }
24.     const_iterator begin() const{return data;   }
25.     iterator end() {return avail;   }
26.     const_iterator end() const {return avail;   }
27.     size_type size() const{return avail-data;}
28. void push_back(const T&);
29. ​
30. private:
31.     iterator data,avail,limit;
32.     std::allocator<T> alloc;
33. ​
34. void create();
35. void create(size_type,const T&);
36. void create(const_iterator,const_iterator);
37. void uncreate();
38. void grow();
39. void unchecked_appended(const T&);
40. };
41. ​
42. #endif
43. ​
44. template <class T> void Vec<T>::create(){
45.     data=avail=limit=0;
46. }
47. ​
48. template <class T> void Vec<T>::create(size_type n,const T& t){
49.     data=alloc.allocate(n);
50.     avail=limit=data+n;
51.     std::uninitialized_fill(data,limit,t);
52. ​
53. }
54. ​
55. template <class T> void Vec<T>::create(const_iterator i,const_iterator j){
56.     data=alloc.allocate(j-i);
57.     avail=limit=std::uninitialized_copy(i,j,data);
58. ​
59. }
60. ​
61. template <class T> void Vec<T>::uncreate(){
62. if(data){
63.       iterator i=avail;
64. while(i!=data)
65.         alloc.destroy(--i);
66.       alloc.deallocate(data,limit-data);
67.     }
68.     data=avail=limit=0;
69. ​
70. }
71. ​
72. template <class T> void Vec<T>::grow(){
73.     size_type maxlen;
74.     maxlen=std::max(2*(limit-data),ptrdiff_t(1));            //确定vector容量
75. ​
76.     iterator new_data,new_avail;
77.     new_data=alloc.allocate(maxlen);                    //申请未初始化的内存空间
78.     new_avail=std::uninitialized_copy(data,avail,new_data);       //拷贝工作
79.     uncreate();                                             //删除工作
80.     data=new_data;
81.     avail=new_avail;
82.     limit=data+maxlen;                               //更新limit
83. }
84. ​
85. template <class T> void Vec<T>::unchecked_appended(const T& v){
86.     alloc.construct(avail++,v);                             //特别注意这里在未初始化的内存中构造v对象
87. }
88. ​
89. template <class T> Vec<T>& Vec<T>::operator=(const Vec& v){
90. if(&v != this){
91.         uncreate();
92.         create(v.begin(),v.end());
93.     }
94. return *this;
95. }
96. ​
97. template <class T> void Vec<T>:: push_back(const T& v){
98. if(avail==limit)
99.         grow();
100.     unchecked_appended(v);
101. ​
102. }

测试例程

cpp view plain copy

1. #include"vec.h"
2. ​
3. #include<iostream>
4. ​
5. using namespace std;
6. ​
7. int main(){
8.     Vec<int> v;
9. ​
10.     cout<<v.size()<<endl;
11.     v.push_back(1);
12.     v.push_back(12);
13.     v.push_back(51);
14.     v.push_back(136);
15. ​
16.     Vec<int>::iterator i;
17. for(i=v.begin();i!=v.end();i++)
18.       cout<< *i <<"\t";
19.     cout<<endl;
20. ​
21.     Vec<int> v1=v;
22. for(i=v1.begin();i!=v1.end();i++)
23.       cout<< *i <<"\t";
24.     cout<<endl;
25. ​
26.     Vec<int> v3(v);
27. for(i=v3.begin();i!=v3.end();i++)
28.       cout<< *i <<"\t";
29.     cout<<endl;
30.     v3.push_back(112);
31.     v3.push_back(172);
32.     v3.push_back(120);
33. for(i=v3.begin();i!=v3.end();i++)
34.       cout<< *i <<"\t";
35. ​
36. }

声明：本文为原创，作者为 对弈，转载时请保留本声明及附带文章链接：https://cloud.tencent.com/developer/article/1498813