oj 贵州大学 第四次作业（c++）（运算符重载）第四题

定义一个MyArray类，内部有私有成员int size和int *ptr。

创建该类对象时，在构造函数中用 new动态内存分配一个长度为 size的一维整型数组并用 ptr成员存储该数组的首地址。析构函数要释放动态数组。

为该类重载以下运算符：

（1）下标运算符[ ]，利用该下标运算符实现对数组元素的读写访问

（2）赋值运算符，实现MyArray对象之间正确的深层赋值。

（3）+运算符，实现两个MyArray对象的数组的对应元素相加，返回一个新的MyArray对象，该对象的数组中存储了之前两个数组对应元素相加的结果。

（4）-运算符，实现两个MyArray对象的数组的对应元素相减，返回一个新的MyArray对象，该对象的数组中存储了之前两个数组对应元素相减的结果。

（5）*运算符，将两个MyArray对象的数组视作向量，该运算符用于求向量内积

（6）<<运算符，实现使用cout输出对象的数组的内容

此外，该类的复制构造函数要正确实现深层复制。

main函数已经写好，请根据main函数的内容完成该类的设计：

int main(){

int n;

cin>>n;

MyArray arr1(n);

for(int i=0;i<arr1.getSize();i++)

cin>>arr1[i];

cout<<arr1;

MyArray arr2(arr1);

for(int i=0;i<arr2.getSize();i++)

arr2[i]+=1;

cout<<arr2;

MyArray arr3,arr4;

arr3=arr2+arr1;

cout<<arr3;

arr4=arr2-arr1;

cout<<arr4;

cout<<arr1*arr2<<endl;

return 0;

}

输入描述先输入变量n，创建一个MyArray对象，其对应的数组有n个元素

然后输入数组的n个元素的值

输出描述根据样例输出

提示你需要提交除了main函数之外的其他代码。

样例输入  

5
1 2 3 4 5

样例输出

1,2,3,4,5
2,3,4,5,6
3,5,7,9,11
1,1,1,1,1
70
 

#include<iostream>
using namespace std;
#define null 0
class MyArray {
private:
    int size;
    int* ptr;
public:
    MyArray() { size = 0; ptr = null; }
    MyArray(int size)
    {
        this->size = size;
        ptr = new int[size];
    }
    MyArray(const MyArray& a)
    {
        size = a.size;
        ptr = new int[size];
        for (int i = 0; i < size; i++)
        {
            ptr[i] = a.ptr[i];
        }
    }
    ~MyArray()
    {
        delete[]ptr;
    }
    int getSize() { return size;}
    int &operator[](int &index)
    {
        return this->ptr[index];
    }
    friend ostream& operator<<(ostream& out, const MyArray& m)
    {
        for (int i = 0; i < m.size; i++)
        {
            if (i >=0 && i < m.size - 1)
                out << m.ptr[i] << ",";
            else
                out << m.ptr[i];
        }
        out << endl;
        return out;
    }
    friend MyArray& operator+(const MyArray& c1, const MyArray& c2)
    {
        MyArray *c3=new MyArray(c1.size);
        for (int i = 0; i < c1.size; i++)
        {
            c3->ptr[i] = c1.ptr[i] + c2.ptr[i];
        }
        return *c3;
    }
    friend int operator*(const MyArray& c1, const MyArray& c2)
    {
        int num = 0;
        MyArray* c3 = new MyArray(c1.size);
        for (int i = 0; i < c1.size; i++)
        {
            c3->ptr[i] = c1.ptr[i] * c2.ptr[i];
            num += c3->ptr[i];
        }
        return num;
    }

    friend MyArray& operator-(const MyArray& c1, const MyArray& c2)
    {
        MyArray* c3 = new MyArray(c1.size);
        for (int i = 0; i < c1.size; i++)
        {
            c3->ptr[i] = c1.ptr[i] - c2.ptr[i];
        }
        return *c3;
    }
    MyArray& operator=(const MyArray& M)
    {
        if (ptr)delete[]ptr;
        size = M.size;
        ptr = new int[size];
        for (int i = 0; i < M.size; i++)
            ptr[i] = M.ptr[i];
        
        return *this;
    }

};