定义一个矩阵类MyMatrix，并且在类中进行运算符重定义，用*实现矩阵相乘。要求必须对运算符进行重载，如果用函数如multiply（matrix，matrix）去实现矩阵之间的运算一律记0分。 必须包含以下析构函数，其中n是矩阵的阶数，data是存放矩阵数据的二维动态数组： MyMatrix::~MyMatrix() { // 释放空间 for (int i = 0; i < n; i++) { delete[] data[i]; } delete[] data; } 输入 第一行输入所需要的矩阵个数c; 第二行输入矩阵的阶数n，即矩阵是一个n*n的矩阵; 第三行开始依次输入c个矩阵. 输出 c个矩阵相乘的结果

好的，根据您的要求，我为您编写了如下代码：

#include <iostream>
using namespace std;

class MyMatrix {
private:
    int n; // 矩阵的阶数
    int** data; // 存放矩阵数据的二维动态数组
public:
    MyMatrix(int n) {
        this->n = n;
        data = new int*[n];
        for (int i = 0; i < n; i++) {
            data[i] = new int[n];
            for (int j = 0; j < n; j++) {
                data[i][j] = 0; // 初始化为0
            }
        }
    }
    ~MyMatrix() {
        // 释放空间
        for (int i = 0; i < n; i++) {
            delete[] data[i];
        }
        delete[] data;
    }
    MyMatrix operator*(const MyMatrix& other) {
        MyMatrix result(n);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    result.data[i][j] += data[i][k] * other.data[k][j];
                }
            }
        }
        return result;
    }
    void input() {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                cin >> data[i][j];
            }
        }
    }
    void output() {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                cout << data[i][j] << " ";
            }
            cout << endl;
        }
    }
};

int main() {
    int c, n;
    cin >> c >> n;
    MyMatrix* matrices = new MyMatrix[c];
    for (int i = 0; i < c; i++) {
        matrices[i] = MyMatrix(n);
        matrices[i].input();
    }
    MyMatrix result = matrices[0];
    for (int i = 1; i < c; i++) {
        result = result * matrices[i];
    }
    result.output();
    delete[] matrices;
    return 0;
}

这个程序定义了一个矩阵类`MyMatrix`，并且重载了运算符`*`来实现矩阵相乘。在主函数中，首先输入所需要的矩阵个数`c`和矩阵的阶数`n`，然后依次输入`c`个矩阵，将它们相乘得到结果并输出。在程序结束时，会自动调用类的析构函数来释放矩阵占用的内存。