【作业】实现miniVector

miniVector.h

1 // miniVector.h: interface for the miniVector class.

2 //

3 //////////////////////////////////////////////////////////////////////

4

5 #if !defined(AFX_MINIVECTOR_H__0C1C5CE6_1DAD_4744_8BEC_47FE8854B154__INCLUDED_)

6 #define AFX_MINIVECTOR_H__0C1C5CE6_1DAD_4744_8BEC_47FE8854B154__INCLUDED_

7

8 #if _MSC_VER > 1000

9 #pragma once

10 #endif // _MSC_VER > 1000

11

12 ////////////////////////////////////////////////////////////////////

13

14 //该miniVector仿照vector的部分功能但又不尽相同，遂作如下说明：

15 // 1、不能创建容量vCapacity为0的对象。

16 // 2、删除最后一个元素时，仅将vSize-1,不对内存进行修改。

17 // 3、使用[]的重载访问元素时，禁止越过vSize访问或修改，即使容量足够。

18 // 4、[]的重载仅可用作读取修改元素，不可用于添加元素。

19 // 5、front() back()函数仅可用作读取修改不可用作添加。

20

21 ////////////////////////////////////////////////////////////////////

22 //其他说明：

23

24

25 class miniVector

26 {

27 private:

28

29 int vCapacity; //储存记录类自身的存储容量

30 int vSize; //储存记录已经存储的元素个数

31 int *vArr; //储存记录动态数组的首地址

32

33 void reserve(int n,bool copy); //根据传入参数n申请内存大小，根据copy判断是否保留原有元素

34 //该函数可实现在创建对象时申请储存空间，以及动态调整储存

35 //空间的大小即调整自身的存储容量(capacity)

36

37 public:

38

39

40 miniVector(); //缺省构造函数创建容量为10的对象

41 miniVector(int size); //重载构造函数创建容量为size的对象

42 miniVector(int size, int item); //重载构造函数创建容量为size，大小为size的元素内容都为item的对象

43 miniVector(int*a1, int* a2); //重载构造函数借助数组初始化对象 a1、a2为数组内容的起始地址和结束地址

44 miniVector( const miniVector &obj); //拷贝构造函数初始化化与obj相同的对象

45

46 int& back(); //返回最后一个元素的引用

47 int& front(); //返回首个元素的引用

48 const int& back() const; //const修饰的对象只能调用function() const 修饰的成员函数所以重载这个函数

49 const int& front() const;

50

51 miniVector& operator=( const miniVector &rhs); //重载等号运算符用于对象拷贝

52

53 int& operator[](int i); //重载操作符[] 返回下标为i的元素的引用

54 const int& operator[](int i)const; //重载带const修饰的函数

55

56 void push_back(const int& item); //将item添加到尾部

57 void pop_back(); //删除最后一个元素

58

59 int size() const; //返回当前对象的vSize大小

60 int capacity() const; //返回当前对象的vCapacity大小

61 bool empty() const; //返回当前对象是否为空 空则返回True

62 bool at(int i)const; //判断当前下标是否越界 越界则程序中止 输出提示返回true 未越界返回false

63

64 void swap(miniVector &v); //将当前对象与v进行交换

65 void insert(int p,const int& item); //在下标为p的位置插入1个item元素

66 void insert(int p,int n, const int& item); //在下标为p的位置插入n个item元素

67 void erase(int p); //删除下标为p的元素

68 void erase(int p1, int p2); //删除下标从p1~p2的元素

69 void display(); //输出当前对象的所有元素

70 void display(int p1,int p2); //输出下标从p1~p2的元素

71 ~miniVector(); //析构函数，释放内存

72

73 };

74

75 #endif // !defined(AFX_MINIVECTOR_H__0C1C5CE6_1DAD_4744_8BEC_47FE8854B154__INCLUDED_)

View Code

miniVector.cpp

1 // miniVector.cpp: implementation of the miniVector class.

2 //

3 //////////////////////////////////////////////////////////////////////

4

5 #include "stdafx.h"

6 #include "miniVector.h"

7

8 #include

9 using namespace std;

10 //////////////////////////////////////////////////////////////////////

11 // Construction/Destruction

12 //////////////////////////////////////////////////////////////////////

13

14 miniVector::miniVector()

15 {

16

17 vArr=NULL;

18 reserve(10,false); //默认创建容量为10的空对象

19

20 }

21 miniVector::miniVector(int size)

22 {

23 //不对size进行检测 交给reserve()函数

24 vArr=NULL;

25 reserve(size,false);

26

27 }

28 miniVector::miniVector(int size, int item)

29 {

30 vArr=NULL;

31 reserve(size, false);

32 //for循环为元素赋值并调整vSize;

33 for (int i = 0; i

34 {

35 vArr[i] = item;

36 vSize++;

37 }

38

39 }

40

41 //借助数组内存地址初始化对象

42 miniVector::miniVector(int* a1, int* a2)

43 {

44 vArr=NULL;

45 reserve(a2 - a1, false);

46 for (int i = 0; i < (a2 - a1); i++)

47 {

48 vArr[i] = a1[i];

49 vSize++;

50 }

51 }

52

53

54 void miniVector::reserve(int n,bool copy) //可以完成vCapacity、vArr或vSize赋值等一系列操作

55 {

56

57 if(n<=0) //申请的空间大小的检测，不允许小于等于0

58 {

59 cout<<"reserve函数参数错误，程序已被中止，请重新运行！\n";

60 system("pause");

61 exit(1);

62

63 }

64 else

65 {

66 int *newArr= new int[n];

67 if(newArr==NULL)

68 {

69 cout<<"reserve函数申请内存失败，程序已被中止，请重新运行！\n";

70 system("pause");

71 exit(1);

72 }

73 else

74 {

75 vCapacity=n; //容量大小的确定 调用reserve 申请后无需再次改变大小

76 int newvSize=0; //记录重新申请的内存储存元素的个数

77 if(copy)

78 {

79 newvSize=(n

80 for(int i=0;i

81 {

82 newArr[i]=vArr[i];

83 }

84 }

85 vSize = newvSize; //初始化 或 改变vSize 的大小

86

87

88 if(vArr!=NULL)delete[] vArr; //若原数组首地址不为空则释放内存区域

89 vArr=newArr;

90 }

91

92 }

93 }

94

95 miniVector::miniVector(const miniVector &obj)

96 {

97 vArr=NULL;

98 reserve(obj.capacity(),false); //调用完成后便已经完成vCapacity、vArr赋值

99 for(int i=0;i

100 {

101 vArr[i]=obj[i];

102 }

103 vSize=obj.size();

104 }

105

106 miniVector& miniVector::operator=(const miniVector &obj) //！！！！！const 修饰的对象只能调用function() const 防止成员变量被修改

107 {

108 cout << "等号重载被调用！\n"; //输出信息验证等号重载是否成功调用

109 reserve(obj.capacity(),false); //调用完成后便已经完成vCapacity、vArr赋值

110 for(int i=0;i

111 {

112 vArr[i]=obj[i];

113

114 }

115 vSize=obj.size();

116 return *this;

117 }

118

119 const int& miniVector::operator[](int i)const

120 {

121 at(i);

122 return vArr[i];

123

124

125 }

126

127 int& miniVector::operator[](int i) //若用于添加数值则miniVector 无法正常工作

128 {

129

130 at(i);

131 return vArr[i];

132

133 }

134

135 int miniVector::capacity() const

136 {

137 return vCapacity;

138 }

139 int miniVector::size() const

140 {

141 return vSize;

142 }

143

144

145 //仅用作读取修改 不可用作添加

146 int& miniVector::back()

147 {

148 at(vSize - 1);

149 return vArr[vSize - 1];

150 }

151

152 int& miniVector::front()

153 {

154 at(0);

155 return vArr[0];

156 }

157

158

159

160 const int& miniVector::back() const

161 {

162 at(vSize - 1);

163 return vArr[vSize-1];

164 }

165

166 const int& miniVector::front() const

167 {

168 at(0);

169 return vArr[0];

170 }

171

172

173 void miniVector::push_back(const int& item)

174 {

175 //判断是否需要扩容

176 //y由于vCapacity 不可能为0 ，vSize=0时必然足够提供一个储存空间

177 if (vSize == vCapacity)

178 {

179 //2倍扩容

180 reserve(vCapacity * 2, true);

181

182 }

183 vSize++;

184 vArr[vSize - 1] = item;

185

186 }

187

188 void miniVector::pop_back()

189 {

190 if (vSize == 0)

191 {

192 cout << "pop_back 函数删除尾部元素失败vSize=0\n";

193 }

194 else

195 {

196 //int 直接将vSize--; 不修改值

197 //若为对象如何调用析构函数

198 vSize--;

199 }

200 }

201

202 bool miniVector::empty() const

203 {

204 return vSize==0;

205 }

206

207 bool miniVector::at(int i) const //下标越界检测

208 {

209 if (i>=vSize||i<0)

210 {

211 cout<< "下标越界，或对象size为0，访问出错，程序已暂停,即将退出！\n"; //输出提示

212 system("pause"); //程序暂停

213 exit(1); //程序退出

214 }

215 else

216 {

217 return false;

218 }

219

220 }

221

222 void miniVector::swap(miniVector &v)

223 {

224 //创建中间对象进行对象交换

225 miniVector temp;

226 temp = v;

227 v = *this;

228 *this = temp;

229 }

230

231 void miniVector::insert(int p,const int& item)

232 {

233 //插入位置检测，若位置错误输出提示，而不结束程序进程

234 if (p<0||p>vSize)

235 {

236 cout << "插入失败，请检查下标\n";

237 return;

238 }

239 if (vSize == vCapacity)

240 {

241 reserve(vCapacity*2, true);

242 }

243

244

245 for (int i=vSize; i>p; i--)

246 {

247 vArr[i]=vArr[i-1];

248 }

249

250 vArr[p]=item;

251 vSize++;

252 }

253

254 void miniVector::insert(int p,int n,const int& item)

255 {

256

257 if (p<0 || p>vSize)

258 {

259 cout << "插入失败，请检查下标\n";

260 return;

261 }

262 if (vSize+n>=vCapacity)

263 {

264 reserve(vCapacity*2+n,true);

265 }

266 for (int i=vSize;i>p;i--)

267 {

268 vArr[i+n-1]=vArr[i-1];

269

270 }

271 for (int j=0;j

272 {

273 vArr[p+j]=item;

274 }

275 vSize+=n;

276

277 }

278

279 void miniVector::erase(int p)

280 {

281 if (p<0||p>=vSize)

282 {

283 cout <<"删除失败，请检查下标\n";

284 return;

285 }

286 for (int i=p;i

287 {

288 vArr[i]=vArr[i+1];

289 }

290 vSize--;

291 }

292 void miniVector::erase(int p1,int p2)

293 {

294

295 if (p1<0||p2>=vSize||p2

296 {

297 cout << "删除失败，请检查下标\n";

298 return;

299 }

300 for(int i=0;i

301 {

302 vArr[p1+i]=vArr[p2+i+1];

303 }

304 vSize-=(p2-p1+1);

305 }

306

307 void miniVector::display()

308 {

309 for(int i=0;i

310 {

311 cout<

312 }

313 cout<

314 }

315 void miniVector::display(int p1,int p2)

316 {

317 if (p1<0||p2>=vSize||p2

318 {

319 cout << "输出失败，请检查下标\n";

320 return;

321 }

322 for(int i=p1;i<=p2;i++)

323 {

324 cout<

325 }

326 cout<

327 }

328 miniVector::~miniVector()

329 {

330 if (vArr!=NULL)delete[] vArr;

331 }

View Code

miniVecterTest.cpp

1 // miniVectorTest.cpp : Defines the entry point for the console application.

2 //

3

4 #include "stdafx.h"

5 #include "miniVector.h"

6 #include

7 using namespace std;

8 int main(int argc, char* argv[])

9 {

10 //重载构造函数（有赋值）及默认输出函数检测

11 cout<<"初始化miniVector vec1(5,1) 并输出\n";

12 miniVector vec1(5,1);

13 vec1.display();

14

15 //借助数组构造函数检测

16 cout<<"\n用数组初始化miniVector vec2 a[10]={1,2,3,4,5,6,7,8,9,10} 并输出\n";

17 int a[10]={1,2,3,4,5,6,7,8,9,10};

18 miniVector vec2(a,a+10);

19 vec2.display();

20

21 //重载输出函数检测

22 cout<<"\n输出vec2部分从vec2[2]~[8]\n";

23 vec2.display(2,8);

24

25 //拷贝构造函数检测

26 cout<<"\n拷贝构造函数初始化vec3并输出\n";

27 miniVector vec3(vec2);

28 vec3.display();

29

30 //默认构造函数及重载等号检测

31 cout << "\n默认构造函数创建vec4,size为0，重载等号vec4=vec2\n";

32 miniVector vec4;

33 vec4=vec2;

34 vec4.display();

35

36 //front() back() 函数检测

37 cout<<"\n输出首尾元素的值 代码：cout<

38 cout<

39

40 cout<<"\n修改首尾元素的值 代码：vec2.front()=11; vec2.back()=12;\n";

41 vec2.front()=11;

42 vec2.back()=12;

43 vec2.display();

44

45

46 //[]重载检测

47 cout<<"\n重载[]修改第二个元素 vec2[1]=13; \n";

48 vec2[1]=13;

49 vec2.display();

50

51 //push_back() pop_back()检测

52 cout<<"\n最后插入14 vec2.push_back(14);\n";

53 vec2.push_back(14);

54 vec2.display();

55

56 cout<<"容量 "<

57 cout<<"\n删除最后一个元素 vec2.pop_back();\n";

58 vec2.pop_back();

59 vec2.display();

60 cout<<"容量 "<

61

62 //重载构造函数（无赋值）及empty()的检测

63 cout<<"\n构建空的vec5 并检测vec5与vec2是否为空 vec5.empty() \n";

64 miniVector vec5(5);

65 cout<

66

67

68 //swap() 检测

69 cout<<"\n交换两个miniVector vec2.swap(vec1) 并输出 vec2 vec1\n";

70 vec2.swap(vec1);

71 vec2.display();

72 vec1.display();

73

74 //insert() 检测

75 cout << "\n试图在错误的位置插入55 vec1.insert(-2,55)\n";

76 vec1.insert(-2, 55);

77 vec1.display();

78 cout << "容量 " << vec1.capacity() << " 大小 " << vec1.size() << endl;

79

80 cout<<"\n第3个位置插入一个22 vec1.insert(2,22)\n";

81 vec1.insert(2,22);

82 vec1.display();

83 cout<<"容量 "<

84

85 cout<<"\n第5个位置插入15个33 vec1.insert(4,15,33)\n";

86 vec1.insert(4,15,33);

87 vec1.display();

88 cout<<"容量 "<

89

90 cout<<"\n\nvec4尾部插入1个0 vec4.insert(10,0)\n";

91 vec4.insert(10,0);

92 vec4.display();

93 cout<<"容量 "<

94

95

96 cout<<"\n\nvec4首部插入1个0 vec4.insert(0,0)\n";

97 vec4.insert(0,0);

98 vec4.display();

99 cout<<"容量 "<

100

101 cout<<"\n\nvec4尾部插入4个1 vec4.insert(12,4,1)\n";

102 vec4.insert(12,4,1);

103 vec4.display();

104 cout<<"容量 "<

105

106

107 //连续push_back检测

108 cout<<"\n方便观察删除的结果，先在vec4后面插上0、1、2、3、4\n";

109 vec4.push_back(0);

110 vec4.push_back(1);

111 vec4.push_back(2);

112 vec4.push_back(3);

113 vec4.push_back(4);

114 vec4.display();

115 cout<<"容量 "<

116

117 //erase() 检测

118 cout<<"\n\nvec4 第4个元素删除 vec4.erase(3) \n";

119 vec4.erase(3);

120 vec4.display();

121 cout<<"容量 "<

122

123 cout<<"\n\nvec4 第5、6、7、8个元素删除 vec4.erase(4,7) \n";

124 vec4.erase(4,7);

125 vec4.display();

126 cout<<"容量 "<

127

128

129 //at()的检测 由于at()检测到越界会结束进程所以放到最后测试

130 cout<<"\n\n检测下标是否越界vec4.at(-44)\n";

131 vec2.at(-44);

132 return 0;

133 }

View Code

源码及实验报告

百度云下载