（3）使用动态二维数组实现矩阵乘法操作。使用c++，写出在vscode2022中可以运行的完整代码，完整代码

在VS Code 2022中，你可以使用C++编写一个简单的动态二维数组矩阵乘法函数。下面是一个完整的示例代码：

#include <iostream>
#include <vector>

// 定义动态二维数组的结构体
struct Matrix {
    int* data;
    int rows, cols;
};

// 动态分配和初始化矩阵
Matrix createMatrix(int rows, int cols) {
    Matrix mat;
    mat.data = new int[rows * cols];
    mat.rows = rows;
    mat.cols = cols;
    return mat;
}

// 释放动态分配的内存
void deleteMatrix(Matrix& mat) {
    delete[] mat.data;
    mat.data = nullptr;
    mat.rows = mat.cols = 0;
}

// 计算两个矩阵的乘积
Matrix matrixMultiplication(const Matrix& A, const Matrix& B) {
    int m1 = A.rows, n1 = A.cols;
    int m2 = B.rows, n2 = B.cols;

    if (n1 != m2) {
        throw std::runtime_error("Invalid dimensions for matrix multiplication.");
    }

    Matrix result = createMatrix(m1, n2);
    int** resultData = result.data;

    for (int i = 0; i < m1; ++i) {
        for (int j = 0; j < n2; ++j) {
            for (int k = 0; k < n1; ++k) {
                resultData[i * n2 + j] += A.data[i * n1 + k] * B.data[k * n2 + j];
            }
        }
    }

    return result;
}

// 打印矩阵
void printMatrix(const Matrix& mat) {
    for (int i = 0; i < mat.rows; ++i) {
        for (int j = 0; j < mat.cols; ++j) {
            std::cout << mat.data[i * mat.cols + j] << " ";
        }
        std::cout << "\n";
    }
}

int main() {
    try {
        Matrix A = createMatrix(2, 2);
        A.data[0] = 1; A.data[1] = 2;
        A.data[2] = 3; A.data[3] = 4;

        Matrix B = createMatrix(2, 2);
        B.data[0] = 5; B.data[1] = 6;
        B.data[2] = 7; B.data[3] = 8;

        Matrix product = matrixMultiplication(A, B);
        printMatrix(product);

        deleteMatrix(A);
        deleteMatrix(B);
        deleteMatrix(product);  // 在这里删除产品矩阵，因为它是临时的
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << '\n';
    }

    return 0;
}

这个代码首先定义了一个包含数据指针、行数和列数的`Matrix`结构体。然后实现了一个简单的矩阵乘法函数，以及创建、打印和销毁矩阵的方法。在`main`函数中，我们创建了两个2x2的矩阵，进行了矩阵乘法，并打印出结果。

请注意，这个代码片段中计算得到的矩阵`product`在完成乘法后需要手动释放，因为它是在堆上动态分配的。如果忘记释放，可能会导致内存泄漏。在实际应用中，可能需要使用智能指针等技术更优雅地管理内存。