STL之vector的学习2（代码实现）（修改版1）

《数据结构与算法分析》的代码！！！！

PS：因为书本没有给clear、erase函数的实现，我也只好自己弄了个clear函数，不过erase函数不知道怎样才能弄好，迟点在改善。

vector的实质也是数组，但是它的容量能动态变大，避免了溢出!!!

PS：加了两条习题的内容。

3.7 修改Vector类，添加索引时的边界检测功能。

3.8 给Vector类添加insert和erase。

 

还有一题未完成，是将迭代器定义为一个类，来提供严格的迭代器检验。这条题目才是真正的考验·····迟点准备做·····

 

  1 #include<iostream>

  2 using namespace std;

  3 

  4 template <typename Object>

  5 class Vector

  6 {

  7 public:

  8     enum { SPARE_CAPACITY = 16 };                       //设置vector没有元素的时候容量为多少。

  9     explicit Vector( int initSize = 0 ) : theSize( initSize ), theCapacity ( initSize + SPARE_CAPACITY )

 10     {

 11         objects = new Object[ theCapacity ];

 12     }                                                   //构造函数。

 13     Vector ( const Vector & rhs) : objects ( NULL )

 14     {

 15         operator=( rhs );

 16     }                                                   //复制构造函数。（实质为调用=操作符重载）。

 17     ~Vector( )

 18     {

 19         delete [ ] objects;

 20     }                                                   //析构函数。

 21 

 22     const Vector &operator= ( const Vector & rhs)

 23     {

 24         if( this != &rhs)

 25         {

 26             delete [ ] objects;

 27             theSize = rhs.size( );

 28             theCapacity = rhs.capacity( );

 29 

 30             objects = new Object [ capacity( ) ];

 31             for(int k = 0; k < size( ); k++)

 32                 objects[ k ] = rhs.objects[ k ];

 33         }

 34         return *this;

 35     }                                                   /*=操作符重载，注意要先判断两个对象是否相等。这个非常重要。自我复制常常被错误的应用

 36                                                           赋值总是用新值取代目标对象的旧值。如果原对象和目标对象是同一个，而我们又奉行“先释放旧值

 37                                                           再复制”的规则，那么可能还没实现复制之前就把原对象销毁。*/

 38 

 39     void resize( int newSize )

 40     {

 41         if( newSize > theCapacity )

 42             reserve( newSize * 2 + 1 );

 43         theSize = newSize;

 44     }                                                   //重新设置vector的大小（与容量比较，因为只有大于容量，容量才要变得更大）。

 45 

 46     void reserve( int newCapacity )

 47     {

 48         if( newCapacity < theCapacity )

 49             return;

 50 

 51         Object *oldArry = objects;

 52 

 53         objects = new Object[ newCapacity ];

 54         for( int k = 0; k < theSize; ++k)

 55             objects[ k ] = oldArry [ k ];

 56         theCapacity = newCapacity;

 57         delete [ ] oldArry;

 58     }                                                    //重新设置vector的容量。

 59 

 60     Object & operator[] ( int index )

 61     {

 62         if( index >= 0 && index < size( ) )

 63             return objects[ index ];

 64         else

 65             cerr << "你要查找的下标超出边界！" << endl;

 66     }

 67     const Object & operator[] ( int index ) const

 68     {

 69         if( index >= 0 && index < size( ) )

 70             return objects[ index ];

 71         else

 72             cerr << "你要查找的下标超出边界！" << endl;

 73     }                                                    //[]操作符的重载。

 74 

 75     bool empty( ) const

 76     {

 77         return size( ) == 0;

 78     }                                                   //判断是否没有元素。

 79     int size( ) const

 80     {

 81         return theSize;

 82     }                                                   //返回元素的数目。

 83     int capacity( ) const

 84     {

 85         return theCapacity;

 86     }                                                   //返回容量的大小。

 87 

 88     void push_back( const Object & x )

 89     {

 90         if( theSize == theCapacity )

 91             reserve( 2 * theCapacity + 1 );

 92         objects[ theSize++ ] = x;

 93     }                                                   //push_back的定义，后插入。

 94 

 95 

 96     void pop_back( )

 97     {

 98         theSize--;

 99     }

100     //删除最后一个元素。

101     void clear( )

102     {

103         delete [ ] objects;

104         theSize = 0;

105     }                                                   //删除所有元素

106 

107     const Object & back ( ) const

108     {

109         return objects[ theSize - 1 ];

110     }                                                   //返回最后一个元素。

111 

112     typedef Object * iterator;

113     typedef const Object * const_iterator;              //迭代器！！！

114 

115     iterator begin( )

116     {

117         return &objects[ 0 ];

118     }

119     const_iterator begin( ) const

120     {

121         return &objects[ 0 ];

122     }

123     iterator end( )

124     {

125         return &objects[ size( ) ];

126     }

127     const_iterator end( ) const

128     {

129         return &objects[ size( ) ];

130     }

131     //begin和end迭代器。

132 

133     iterator insert( iterator p, const Object & x )

134     {

135         int i;

136         Object * oldArry = objects;

137         theSize++;

138         if( theCapacity <= theSize )

139         {

140             theCapacity = 2 * theSize + 1;

141         }

142 

143         objects = new Object[ theCapacity ];

144 

145         for( i = 0; i < size( ); ++i )

146         {

147             if( oldArry[ i ] == *p )

148             {

149                 break;

150             }

151             objects[ i ] = oldArry[ i ];

152         }

153 

154         objects[ i ] = x;

155 

156         for( int j = i + 1; j < size( ); ++j )

157         {

158             objects[ j ] = oldArry[ j -1 ];

159         }

160 

161         delete [ ] oldArry;

162         return  & objects[ i ];

163     }

164                                                         //插入函数。在迭代器p，前插入值为x的新元素。

165     iterator erase( iterator p )

166     {

167         int i;

168         for( i = 0; i < size(); ++i )

169         {

170             if( objects[ i ] == *p )

171             break;

172         }

173 

174         for(int k = i; k < size() - 1; ++k )

175         {

176             objects[ k ] = objects[ k + 1 ];

177         }

178 

179         theSize--;

180         return & objects[ i ];

181     }

182                                                         //删除函数。删除迭代器p指向的元素，返回被删除元素后面的元素。

183 private:

184     int theSize;                                        //元素的数目

185     int theCapacity;                                    //容量的大小

186     Object * objects;                                   //对象的指针。数

187 };

188 

189 int main( )

190 {

191     Vector<int> v1;

192     int newsize, newcapacity;

193     if( v1.empty() )

194         cout << "vector里面没有元素！" << endl;

195     else

196         cout << "vector里面有元素！" << endl;

197 

198     int n, m;

199     cout << "输入你想输入元素的数目！" << endl;

200     cout << "可以尝试一下n大于16。（因为设置了vector的默认容量为16）（大于vector的最大容量时，vector的最大容量会自动变大！）" << endl;

201     cin >> n;

202         for(int i = 0; i < n; ++i)

203     {

204         cin >> m;

205         v1.push_back( m );

206         cout << "vector的size（里面有多少的元素）：" << endl;

207         cout << v1.size() << endl;

208         cout << "vector的实际大小（最多能装多少元素）：" << endl;

209         cout << v1.capacity() << endl;

210     }

211     cout << endl;

212 

213     cout << "以下通过对迭代器解引用输出迭代器所指向的值！" << endl;

214     for(Vector<int>::iterator itr = v1.begin(); itr != v1.end(); ++itr)

215         cout << *itr << " " ;

216     cout << endl;

217     cout << "重新设置vector的大小，输入你想要vector的大小：" << endl;

218     cin >> newsize;

219     v1.resize( newsize );

220     cout << "vector的size（里面有多少的元素）：" << endl;

221     cout << v1.size() << endl;

222     cout << "vector的实际大小（最多能装多少元素）：" << endl;

223     cout << v1.capacity() << endl;

224     cout << "重新设置vector的容量大小，输入你想要vector的容量：" << endl;

225     cin >> newcapacity;

226     v1.reserve(newcapacity);

227     cout << "vector的size（里面有多少的元素）：" << endl;

228     cout << v1.size() << endl;

229     cout << "vector的实际大小（最多能装多少元素）：" << endl;

230     cout << v1.capacity() << endl;

231     cout << "判断vector是否没有元素（不是容量为0）" << endl;

232     if( v1.empty() )

233         cout << "vector里面没有元素！" << endl;

234     else

235         cout << "vector里面有元素！" << endl;

236 

237     cout << "以下调用insert函数！" << endl;

238     int pos1;

239     cout << "输入你想在哪一个位置的迭代器前插入元素！" << endl;

240     cout << "注意不能大于或等于v1的元素数目："  << v1.size() << endl;

241     cin >> pos1;

242     Vector<int>::iterator itr1 = v1.begin() + pos1;

243     int in;

244     cout << "输入你想插入的元素的值！" << endl;

245     cin >> in;

246     v1.insert( itr1, in );

247     cout << "v1的元素的数目！" << endl;

248     cout << v1.size() << endl;

249     for(Vector<int>::iterator itr = v1.begin(); itr != v1.end(); ++itr)

250         cout << *itr << " ";

251     cout << endl;

252 

253     cout << "以下为调用erase函数的例子" << endl;

254     cout << "输入你想删除的元素的位置" << endl;

255     int pos2;

256     cin >> pos2;

257     Vector<int>::iterator itr2 = v1.begin() + pos2;

258     v1.erase( itr2 );

259     for(int i = 0; i < v1.size(); ++i)

260     cout << v1[i] << " ";

261     cout << endl;

262 

263     cout << "以下为调用复制构造函数！" << endl;

264     Vector<int> v2(v1);

265     for(Vector<int>::iterator itr= v2.begin(); itr != v2.end(); ++itr)

266         cout << *itr << " " ;

267     cout << endl;

268 

269     cout << "以下调用=操作符的重载" << endl;

270     Vector<int> v3 = v1;

271     for(Vector<int>::iterator itr= v3.begin(); itr != v3.end(); ++itr)

272         cout << *itr << " " ;

273     cout << endl;

274 

275     cout << "以下调用clear函数！" << endl;

276     v1.clear();

277     if( v1.empty() )

278         cout << "vector里面没有元素！" << endl;

279     else

280         cout << "vector里面有元素！" << endl;

281     return 0;

282 }