实现一个矩阵类，可以实现矩阵的乘法。提示：在构造时指定矩阵的两维大小，同时开辟存储矩阵的空间，两个矩阵相乘后存入第三个矩阵对象中

可以回答这个问题。实现一个矩阵类，可以实现矩阵的乘法，可以按照以下步骤进行：

1. 在构造函数中指定矩阵的两维大小，并开辟存储矩阵的空间。
2. 实现矩阵乘法的运算符重载函数，将两个矩阵相乘后存入第三个矩阵对象中。
3. 在析构函数中释放存储矩阵的空间。

具体实现可以参考以下代码：

class Matrix {
public:
    Matrix(int row, int col) {
        this->row = row;
        this->col = col;
        data = new int*[row];
        for (int i = 0; i < row; i++) {
            data[i] = new int[col];
        }
    }

    ~Matrix() {
        for (int i = 0; i < row; i++) {
            delete[] data[i];
        }
        delete[] data;
    }

    Matrix operator*(const Matrix& other) const {
        Matrix result(row, other.col);
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < other.col; j++) {
                result.data[i][j] = 0;
                for (int k = 0; k < col; k++) {
                    result.data[i][j] += data[i][k] * other.data[k][j];
                }
            }
        }
        return result;
    }

private:
    int row;
    int col;
    int** data;
};

使用示例：

Matrix A(2, 3);
A.data[0][0] = 1;
A.data[0][1] = 2;
A.data[0][2] = 3;
A.data[1][0] = 4;
A.data[1][1] = 5;
A.data[1][2] = 6;

Matrix B(3, 2);
B.data[0][0] = 7;
B.data[0][1] = 8;
B.data[1][0] = 9;
B.data[1][1] = 10;
B.data[2][0] = 11;
B.data[2][1] = 12;

Matrix C = A * B;

此时，C 中存储的就是 A 和 B 的乘积。