重载函数 数组



1. /* 
2. *Copyright(c) 2016.烟台大学计算机与控制工程学院 
3. *ALL rights  reserved. 
4. *文件名称：test.cpp 
5. *作者：隋宗涛 
6. *完成日期：2016年5月23 
7. *问题描述: 设计数组类Array，为了实现测试函数中要求的功能，请补足相关的函数（构造、析构函数） 
8.            和运算符重载的函数。请注意引用的用法。 
9. */  
10. #include <iostream>  
11. #include <iomanip>  
12. #include <cassert>  
13. using namespace std;  
14. class Array  
15. {  
16. private:  
17.     int* list;      //用于存放动态分配的数组内存首地址  
18.     int size;       //数组大小（元素个数）  
19. public:  
20.     Array(int sz = 50);     //构造函数  
21.     Array(int a[], int sz);     //构造函数  
22.     Array(const Array &a);  //拷贝构造函数  
23.     ~Array();          //析构函数  
24.     Array operator + (const Array &a2);     //重载"+"  
25.     Array &operator = (const Array &a2);    //重载"="  
26.     int &operator[] (int i); //重载"[]"  
27.     const int &operator[] (int i) const;  
28.     int getSize() const;        //取数组的大小  
29.     void resize(int sz);        //修改数组的大小  
30.     void show() const;  
31. };  
32. Array::Array(int sz)  //构造函数  
33. {  
34.     assert(sz >= 0);//sz为数组大小（元素个数），应当非负  
35.     size = sz;  // 将元素个数赋值给变量size  
36.     list = new int [size];  //动态分配size个int类型的元素空间  
37. }  
38. Array::Array(int a[], int sz)  
39. {  
40.     assert(sz >= 0);//sz为数组大小（元素个数），应当非负  
41.     size = sz;  // 将元素个数赋值给变量size  
42.     list = new int [size];  //动态分配size个int类型的元素空间  
43.     for (int i = 0; i < size; i++) //从对象X复制数组元素到本对象  
44.         list[i] = a[i];  
45. }  
46. Array::~Array()   //析构函数  
47. {  
48.     delete [] list;  
49. }  
50. //拷贝构造函数  
51. Array::Array(const Array &a)  
52. {  
53.     size = a.size; //从对象x取得数组大小，并赋值给当前对象的成员  
54.     //为对象申请内存并进行出错检查  
55.     list = new int[size];   // 动态分配n个int类型的元素空间  
56.     for (int i = 0; i < size; i++) //从对象X复制数组元素到本对象  
57.         list[i] = a.list[i];  
58. }  
59. Array Array::operator + (const Array &a2)  
60. {  
61.     assert(size == a2.size);    //检查下标是否越界  
62.     //如果本对象中数组大小与a2不同，则删除数组原有内存，然后重新分配  
63.     Array total(size);  
64.     for (int i = 0; i < size; i++)  
65.         total.list[i] = list[i]+a2.list[i];  
66.     return total;   //返回当前对象的引用  
67. }  
68. //重载"="运算符，将对象a2赋值给本对象。实现对象之间的整体赋值  
69. Array &Array::operator = (const Array& a2)  
70. {  
71.     if (&a2 != this)  
72.     {  
73.         //如果本对象中数组大小与a2不同，则删除数组原有内存，然后重新分配  
74.         if (size != a2.size)  
75.         {  
76.             delete [] list; //删除数组原有内存  
77.             size = a2.size; //设置本对象的数组大小  
78.             list = new int[size];   //重新分配n个元素的内存  
79.         }  
80.         //从对象X复制数组元素到本对象  
81.         for (int i = 0; i < size; i++)  
82.             list[i] = a2.list[i];  
83.     }  
84.     return *this;   //返回当前对象的引用  
85. }  
86.   
87. //重载下标运算符，实现与普通数组一样通过下标访问元素，并且具有越界检查功能  
88. int &Array::operator[] (int n)  
89. {  
90.     assert(n >= 0 && n < size); //检查下标是否越界  
91.     return list[n];         //返回下标为n的数组元素  
92. }  
93. //常对象时，会调用这个函数，运算结果(引用)将不能再被赋值  
94. const int &Array::operator[] (int n) const  
95. {  
96.     assert(n >= 0 && n < size); //检查下标是否越界  
97.     return list[n];         //返回下标为n的数组元素  
98. }  
99. //取当前数组的大小  
100. int Array::getSize() const  
101. {  
102.     return size;  
103. }  
104. //将数组大小修改为sz  
105. void Array::resize(int sz)  
106. {  
107.     assert(sz >= 0);    //检查sz是否非负  
108.     if (sz == size) //如果指定的大小与原有大小一样，什么也不做  
109.         return;  
110.     int* newList = new int [sz];    //申请新的数组内存  
111.     int n = (sz < size) ? sz : size;//将sz与size中较小的一个赋值给n  
112.     //将原有数组中前n个元素复制到新数组中  
113.     for (int i = 0; i < n; i++)  
114.         newList[i] = list[i];  
115.     delete[] list;      //删除原数组  
116.     list = newList; // 使list指向新数组  
117.     size = sz;  //更新size  
118. }  
119. void Array::show() const  
120. {  
121.     for (int i = 0; i < size; i++)  
122.         cout<< list[i]<<" ";  
123.     cout<<endl;  
124. }  
125. int main()  
126. {  
127.     int a[8]= {1,2,3,4,5,6,7,8};  
128.     int b[8]= {10,20,30,40,50,60,70,80};  
129.     Array array1(a,8),array3,array4;  
130.     const Array array2(b,8);  
131.     array4=array3=array1+array2;  
132.     array3.show();  
133.     array4.resize(20);  
134.     array4[8]=99;  
135.     cout<<array4[8]<<endl;  
136.     cout<<array2[3]<<endl;  
137.     return 0;  
138. }  

139. /*
     *Copyright(c) 2016.烟台大学计算机与控制工程学院
     *ALL rights  reserved.
     *文件名称：test.cpp
     *作者：杨驰
     *完成日期：2016年5月23
     *问题描述: 设计数组类Array，为了实现测试函数中要求的功能，请补足相关的函数（构造、析构函数）
                和运算符重载的函数。请注意引用的用法。
     */
     #include <iostream>
     #include <iomanip>
     #include <cassert>
     using namespace std;
     class Array
     {
     private:
         int* list;      //用于存放动态分配的数组内存首地址
         int size;       //数组大小（元素个数）
     public:
         Array(int sz = 50);     //构造函数
         Array(int a[], int sz);     //构造函数
         Array(const Array &a);  //拷贝构造函数
         ~Array();          //析构函数
         Array operator + (const Array &a2);     //重载"+"
         Array &operator = (const Array &a2);    //重载"="
         int &operator[] (int i); //重载"[]"
         const int &operator[] (int i) const;
         int getSize() const;        //取数组的大小
         void resize(int sz);        //修改数组的大小
         void show() const;
     };
     Array::Array(int sz)  //构造函数
     {
         assert(sz >= 0);//sz为数组大小（元素个数），应当非负
         size = sz;  // 将元素个数赋值给变量size
         list = new int [size];  //动态分配size个int类型的元素空间
     }
     Array::Array(int a[], int sz)
     {
         assert(sz >= 0);//sz为数组大小（元素个数），应当非负
         size = sz;  // 将元素个数赋值给变量size
         list = new int [size];  //动态分配size个int类型的元素空间
         for (int i = 0; i < size; i++) //从对象X复制数组元素到本对象
             list[i] = a[i];
     }
     Array::~Array()   //析构函数
     {
         delete [] list;
     }
     //拷贝构造函数
     Array::Array(const Array &a)
     {
         size = a.size; //从对象x取得数组大小，并赋值给当前对象的成员
         //为对象申请内存并进行出错检查
         list = new int[size];   // 动态分配n个int类型的元素空间
         for (int i = 0; i < size; i++) //从对象X复制数组元素到本对象
             list[i] = a.list[i];
     }
     Array Array::operator + (const Array &a2)
     {
         assert(size == a2.size);    //检查下标是否越界
         //如果本对象中数组大小与a2不同，则删除数组原有内存，然后重新分配
         Array total(size);
         for (int i = 0; i < size; i++)
             total.list[i] = list[i]+a2.list[i];
         return total;   //返回当前对象的引用
     }
     //重载"="运算符，将对象a2赋值给本对象。实现对象之间的整体赋值
     Array &Array::operator = (const Array& a2)
     {
         if (&a2 != this)
         {
             //如果本对象中数组大小与a2不同，则删除数组原有内存，然后重新分配
             if (size != a2.size)
             {
                 delete [] list; //删除数组原有内存
                 size = a2.size; //设置本对象的数组大小
                 list = new int[size];   //重新分配n个元素的内存
             }
             //从对象X复制数组元素到本对象
             for (int i = 0; i < size; i++)
                 list[i] = a2.list[i];
         }
         return *this;   //返回当前对象的引用
     }
     
     //重载下标运算符，实现与普通数组一样通过下标访问元素，并且具有越界检查功能
     int &Array::operator[] (int n)
     {
         assert(n >= 0 && n < size); //检查下标是否越界
         return list[n];         //返回下标为n的数组元素
     }
     //常对象时，会调用这个函数，运算结果(引用)将不能再被赋值
     const int &Array::operator[] (int n) const
     {
         assert(n >= 0 && n < size); //检查下标是否越界
         return list[n];         //返回下标为n的数组元素
     }
     //取当前数组的大小
     int Array::getSize() const
     {
         return size;
     }
     //将数组大小修改为sz
     void Array::resize(int sz)
     {
         assert(sz >= 0);    //检查sz是否非负
         if (sz == size) //如果指定的大小与原有大小一样，什么也不做
             return;
         int* newList = new int [sz];    //申请新的数组内存
         int n = (sz < size) ? sz : size;//将sz与size中较小的一个赋值给n
         //将原有数组中前n个元素复制到新数组中
         for (int i = 0; i < n; i++)
             newList[i] = list[i];
         delete[] list;      //删除原数组
         list = newList; // 使list指向新数组
         size = sz;  //更新size
     }
     void Array::show() const
     {
         for (int i = 0; i < size; i++)
             cout<< list[i]<<" ";
         cout<<endl;
     }
     int main()
     {
         int a[8]= {1,2,3,4,5,6,7,8};
         int b[8]= {10,20,30,40,50,60,70,80};
         Array array1(a,8),array3,array4;
         const Array array2(b,8);
         array4=array3=array1+array2;
         array3.show();
         array4.resize(20);
         array4[8]=99;
         cout<<array4[8]<<endl;
         cout<<array2[3]<<endl;
         return 0;
     }
     

运行结果：