第12周项目3：数组类运算的实现

/* 
 * Copyright(c)2016,烟台大学计算机与控制工程学院 
 * All rights reserved. 
 * 文件名称：第12周项目3：数组类运算的实现 
 * 作者：马康泰
 * 完成日期：2016.5.19 
 * 版本号：v1.0 
 * 
 * 问题描述：设计数组类Array，为了实现测试函数中要求的功能，请补足相关的函数（构造、析构函数）和运算符重载的函数。请注意引用的用法。 
   实现策略提示：可以将测试函数中的语句加上注释，取消一句的注释，增加相应的函数，以渐增地实现所有的功能，避免全盘考虑带来的困难。 
 * 输入描述： 
 * 程序输出： 
 */  
#include<iostream>  
using namespace std;  
class Array  
{  
private:  
    int* list;      //用于存放动态分配的数组内存首地址  
    int size;       //数组大小（元素个数）  
public:  
    //成员函数声明  
    Array(int sz = 50);     //构造函数  
    Array(int ar[],int n); //构造函数  
    Array(const Array &a);  //拷贝构造函数  
   Array operator+(const Array &a);  //数组的和  
    Array &operator=(const Array &a);  //数组赋值  
   int &operator[] (int n); //下标函数  
    const int &operator[] (int i) const;  
    void show()const;//输出数组  
    void resize(int);//修改数组的大小  
    int getSize() const;        //取数组的大小  
    ~Array();//析构函数，释放空间  
};  
Array::Array(int sz)  //构造函数  
{  
   if(sz >= 0);//sz为数组大小（元素个数），应当非负  
    size = sz;  // 将元素个数赋值给变量size  
   list = new int [size];  //动态分配size个int类型的元素空间  
}  
//重载下标运算符，实现与普通数组一样通过下标访问元素，并且具有越界检查功能  
int &Array::operator[] (int n)  
{  
     if(n >= 0 && n < size); //检查下标是否越界  
    return list[n];         //返回下标为n的数组元素  
}  
//常对象时，会调用这个函数，运算结果(引用)将不能再被赋值  
const int &Array::operator[] (int n) const  
{  
    if(n >= 0 && n < size); //检查下标是否越界  
    return list[n];         //返回下标为n的数组元素  
}  
Array::Array(int a[],int sz)  
{  
    if(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::operator+(const Array &a)  //数组的和  
{  
     if(size == a.size);    //检查下标是否越界  
   //如果本对象中数组大小与a2不同，则删除数组原有内存，然后重新分配  
    Array total(size);  
    for (int i = 0; i < size; i++)  
       total.list[i] = this->list[i]+a.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;   //返回当前对象的引用  
}  
void Array::show()const//输出数组  
{  
    int i;  
    for(i=0;i<size;i++)  
    {  
        cout<<list[i]<<" ";  
    }  
   cout<<endl;  
}  
void Array::resize(int n)//修改数组的大小  
{  
    if(n >= 0);    //检查sz是否非负  
    if (n == size) //如果指定的大小与原有大小一样，什么也不做  
        return;  
    int* newList = new int [n];    //申请新的数组内存  
    int k = (n < size) ? n : size;//将sz与size中较小的一个赋值给n  
    //将原有数组中前n个元素复制到新数组中  
    for (int i = 0; i <k; i++)  
        newList[i] = list[i];  
   delete[] list;      //删除原数组  
    list = newList; // 使list指向新数组  
    size = n;  //更新size  
  
}  
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];  
}  
int Array::getSize() const  
{  
    return size;  
}  
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;  
}  

<img src="https://img-blog.csdn.net/20160525211841524?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" />