【作业】实现miniVector

 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_)

  1 // miniVector.cpp: implementation of the miniVector class.
  2 //
  3 //////////////////////////////////////////////////////////////////////
  4 
  5 #include "stdafx.h"
  6 #include "miniVector.h"
  7 
  8 #include <iostream>
  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<size; 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<vSize?n:vSize);            //判断n与vSize的大小，若重申请的空间小于原有元素则保留前n个元素 原则上输入参数n不会比vCapacity小
 80                 for(int i=0;i<newvSize;i++)            //直接用for循环语句进行判断vSize是否为0省去
 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<obj.size();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<obj.size();i++)    //若size为0 则不会进行赋值 
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<n;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<vSize-1; 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<p1)
296     {
297         cout << "删除失败，请检查下标\n";
298         return;
299     }
300     for(int i=0;i<vSize-p2;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<vSize;i++)
310     {
311         cout<<vArr[i]<<‘ ‘;
312     }
313     cout<<endl;
314 }
315 void miniVector::display(int p1,int p2)
316 {
317     if (p1<0||p2>=vSize||p2<p1)
318     {
319         cout << "输出失败，请检查下标\n";
320         return;
321     }
322     for(int i=p1;i<=p2;i++)
323     {
324         cout<<vArr[i]<<‘ ‘;
325     }
326     cout<<endl;
327 }
328 miniVector::~miniVector()
329 {
330     if (vArr!=NULL)delete[] vArr;
331 }

  1 // miniVectorTest.cpp : Defines the entry point for the console application.
  2 //
  3 
  4 #include "stdafx.h"
  5 #include "miniVector.h"
  6 #include <iostream>
  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<<vec2.front()<<‘ ‘<<vec2.back();\n";
 38     cout<<vec2.front()<<‘ ‘<<vec2.back()<<endl;
 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<<"容量 "<<vec2.capacity()<<" 大小 "<<vec2.size()<<endl;
 57     cout<<"\n删除最后一个元素 vec2.pop_back();\n";
 58     vec2.pop_back();
 59     vec2.display();
 60     cout<<"容量 "<<vec2.capacity()<<" 大小 "<<vec2.size()<<endl;
 61 
 62     //重载构造函数（无赋值）及empty()的检测
 63     cout<<"\n构建空的vec5 并检测vec5与vec2是否为空 vec5.empty() \n";
 64     miniVector vec5(5);
 65     cout<<vec5.empty()<<‘ ‘<<vec2.empty()<<endl;
 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<<"容量 "<<vec1.capacity()<<" 大小 "<<vec1.size()<<endl;
 84 
 85     cout<<"\n第5个位置插入15个33 vec1.insert(4,15,33)\n";
 86     vec1.insert(4,15,33);
 87     vec1.display();
 88     cout<<"容量 "<<vec1.capacity()<<" 大小 "<<vec1.size()<<endl;
 89 
 90     cout<<"\n\nvec4尾部插入1个0 vec4.insert(10,0)\n";
 91     vec4.insert(10,0);
 92     vec4.display();
 93     cout<<"容量 "<<vec4.capacity()<<" 大小 "<<vec4.size()<<endl;
 94 
 95 
 96     cout<<"\n\nvec4首部插入1个0 vec4.insert(0,0)\n";
 97     vec4.insert(0,0);
 98     vec4.display();
 99     cout<<"容量 "<<vec4.capacity()<<" 大小 "<<vec4.size()<<endl;
100 
101     cout<<"\n\nvec4尾部插入4个1 vec4.insert(12,4,1)\n";
102     vec4.insert(12,4,1);
103     vec4.display();
104     cout<<"容量 "<<vec4.capacity()<<" 大小 "<<vec4.size()<<endl;
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<<"容量 "<<vec4.capacity()<<" 大小 "<<vec4.size()<<endl;
116 
117     //erase() 检测
118     cout<<"\n\nvec4 第4个元素删除 vec4.erase(3) \n";
119     vec4.erase(3);
120     vec4.display();
121     cout<<"容量 "<<vec4.capacity()<<" 大小 "<<vec4.size()<<endl;
122 
123     cout<<"\n\nvec4 第5、6、7、8个元素删除 vec4.erase(4,7) \n";
124     vec4.erase(4,7);
125     vec4.display();
126     cout<<"容量 "<<vec4.capacity()<<" 大小 "<<vec4.size()<<endl;
127 
128 
129     //at()的检测 由于at()检测到越界会结束进程所以放到最后测试
130     cout<<"\n\n检测下标是否越界vec4.at(-44)\n";
131     vec2.at(-44);
132     return 0;
133 }