Simple rewriting of container vector and rewriting of vector
1 # pragma once 2 # include <iostream> 3 using namespace std; 4 5 template <class T> 6 class CMyVector 7 {8 public: 9 CMyVector () {buff = NULL; len = maxSize = 0;} 10 ~ CMyVector () {_ clear ();} 11 size_t capacity (); 12 size_t size (); 13 bool empty (); 14 void print (); 15 // iterator 16 struct MyIterator 17 {18 T * pt; 19 MyIterator () {pt = NULL;} 20 MyIterator (MyIterator & it) {pt = it.pt;} 21 ~ MyIterator () {pt = NULL;} 22 MyIterator operator = (const MyIterator & it) {23 pt = it.pt; 24 return * this; 25} 26 bool operator! = (Const MyIterator & it) {27 return (pt! = It.pt); 28} 29 T operator * () {30 return (* pt); 31} 32 MyIterator & operator ++ () {33 ++ pt; 34 return * this; 35} 36 MyIterator operator ++ (int) {37 MyIterator tmp = * this; 38 ++ pt; 39 return tmp; 40} 41 MyIterator operator + (int n) const {42 MyIterator tmp; 43 tmp.pt = pt + n; 44 return tmp; 45} 46 int operator-(const MyIterator & it) const {47 return (pt-it.pt); 48} 49 MyIterator operator -( Int n) {50 MyIterator tmp; 51 tmp.pt = pt-n; 52 return tmp; 53}; 54}; 55 56 MyIterator begin () 57 {58 MyIterator tmp; 59 tmp.pt = buff + 0; 60 return tmp; 61} 62 MyIterator end () 63 {64 MyIterator tmp; 65 tmp.pt = buff + len; 66 return tmp; 67} 68 69 T operator [] (size_t pos) {70 return * (buff + pos); 71} 72 73 void push_back (T t ); 74 void insert (const MyIterator & it, T t); 75 void inser T (const MyIterator & it, const MyIterator & first, const MyIterator & last); 76 void assign (const MyIterator & first, const MyIterator & last ); 77 T at (size_t pos); 78 private: 79 T * buff; 80 size_t len; 81 size_t maxSize; 82 83 void _ clear (); 84 }; 85 86 template <class T> 87 void CMyVector <T>: push_back (T t) 88 {89 if (len> = maxSize) 90 {91 maxSize + = (maxSize> 1)> 1 )? (MaxSize> 1): 1; 92 T * tmp = new T [maxSize]; 93 if (buff) 94 {95 memcpy (tmp, buff, sizeof (T) * len); 96 delete [] buff; 97} 98 buff = tmp; 99} 100 buff [len ++] = t; 101} 102 103 template <class T> 104 void CMyVector <T>: insert (const MyIterator & it, T t) 105 {106 int pos = it-begin (); 107 if (pos> (int) len) 108 return; 109 110 if (len> = maxSize) 111 maxSize + = (maxSize> 1)> 1 )? (MaxSize> 1): 1; 112 113 114 T * tmp = new T [maxSize]; 115 if (buff) {116 memcpy (tmp, buff, sizeof (T) * pos); 117 tmp [pos] = t; 118 memcpy (tmp + pos + 1, buff + pos, sizeof (T) * (len-pos )); 119 delete [] buff; 120} 121 else122 tmp [pos] = t; 123 buff = tmp; 124 + len; 125} 126 127 template <class T> 128 void CMyVector <T>: insert (const MyIterator & it, const MyIterator & first, const MyIterator & last) 129 {130 int Pos = it-begin (); 131 if (pos> (int) len) 132 return; 133 134 int count = 0; 135 if (count = last-first) <= 0) 136 return; 137 138 while (len + count)> = maxSize) 139 maxSize + = (maxSize> 1)> 1 )? (MaxSize> 1): 1; 140 141 142 T * tmp = new T [maxSize]; 143 if (buff) {144 memcpy (tmp, buff, sizeof (T) * pos); 145 for (int I = 0; I <count; ++ I) 146 tmp [pos + I] = * (first + I ); 147 148 memcpy (tmp + pos + count, buff + pos, sizeof (T) * (len-pos); 149 delete [] buff; 150} 151 else152 for (int I = 0; I <count; ++ I) 153 tmp [pos + I] = * (first + I); 154 155 buff = tmp; 156 len + = count; 157 158} 159 160 templa Te <class T> 161 void CMyVector <T>: assign (const MyIterator & first, const MyIterator & last) 162 {163 _ clear (); 164 insert (begin (), first, last); 165} 166 167 template <class T> 168 T CMyVector <T>: at (size_t pos) 169 {170 return * (buff + pos ); 171} 172 173 template <class T> 174 void CMyVector <T >:: _ clear () 175 {176 if (buff) 177 delete [] buff; 178 179 buff = NULL; 180 len = maxSize = 0; 181} 182 183 template <class T> 184 size_t CMyVector <T>: capacity () 185 {186 return maxSize; 187} 188 189 template <class T> 190 size_t CMyVector <T >:: size () 191 {192 return len; 193} 194 195 template <class T> 196 bool CMyVector <T>: empty () 197 {198 return (len = 0 ); 199} 200 201 template <class T> 202 void CMyVector <T>: print () 203 {204/* CMyVector <T >:: MyIterator it; 205 it = begin (); 206 while (it! = End () 207 cout <* it ++ <""; */208 for (auto it = begin (); it! = End (); ++ it) 209 {210 cout <* it <"; 211} 212 cout <endl; 213}