C语言矩阵相乘运算（动态数组）

题目描述：

使用 C 语言编写程序，实现矩阵相乘运算。输入矩阵、输出矩阵、矩阵相乘的功能均需各写成一个函数！！！设第 1 个矩阵为 a，行数和列数分别为 n、p；第 2 个矩阵为 b 行数和列数分别为 p,m，它们的乘积矩阵为 c, 行数和列数分别为 n、m。c 的 i 行 j 列的元素 c(i,j) 的计算规则为：

c(i,j)=a(i,1)*b(1,j)+a(i,2)*b(2,j)+...+a(i,p)*b(p,j), i=1,...,n；j=1,...,m

输入格式：

第 1 行输入三个整数分别表示 n、p、m 后面按行输入第 1 个矩阵和第 2 个矩阵。

输出格式：

乘积矩阵，按行输出，行中数据用一个空格隔开，末尾无空格。

注意：

数组的大小，根据输入的 n、p、m 动态申请!!! 注意适时释放。

输入输出样例：

输入

4 3 2 5 2 4 3 8 2 6 0 4 0 1 6 2 4 1 3 3 2

输出

24 34 20 40 24 32 19 15

解题思路：

动态申请二维数组，输入两个矩阵，再用三重循环算出乘积矩阵。注意：每申请一个数组，就要在最后释放它，防止内存泄漏。

**输入矩阵：**由于是动态申请二维数组，所以需要先输入行列数，再根据行列数申请数组。输入时，使用两重循环，先输入行，再输入列。
**输出矩阵：**也是使用两重循环，先输出行，再输出列，输出完一行后换行。
**计算乘积矩阵：**使用三重循环，先确定乘积矩阵的行列数，再按照计算规则计算每个元素的值。
**释放数组：**由于是动态申请的数组，申请完后要释放掉。因为我们是在函数内部申请的，所以要在函数结束前释放，否则会造成内存泄漏。
完整代码：

#include <stdio.h>
#include <stdlib.h>

void inputMatrix(int **matrix, int rows, int cols) {
    *matrix = (int *)malloc(rows * cols * sizeof(int));
    if (*matrix == NULL) {
        printf("内存分配失败！\n");
        exit(1);
    }
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            scanf("%d", (*matrix + i * cols + j));
        }
    }
}

void outputMatrix(int *matrix, int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", *(matrix + i * cols + j));
        }
        printf("\n");
    }
}

void multiplyMatrix(int *matrixA, int rowsA, int colsA, int *matrixB, int rowsB, int colsB, int **matrixC) {
    *matrixC = (int *)malloc(rowsA * colsB * sizeof(int));
    if (*matrixC == NULL) {
        printf("内存分配失败！\n");
        exit(1);
    }
    for (int i = 0; i < rowsA; i++) {
        for (int j = 0; j < colsB; j++) {
            (*matrixC + i * colsB + j) = 0;
            for (int k = 0; k < colsA; k++) {
                *(*matrixC + i * colsB + j) += *(matrixA + i * colsA + k) * *(matrixB + k * colsB + j);
            }
        }
    }
}

int main() {
    int n, p, m;
    int *matrixA, *matrixB, *matrixC;

    scanf("%d %d %d", &n, &p, &m);

    // 输入矩阵 A
    inputMatrix(&matrixA, n, p);
    // 输入矩阵 B
    inputMatrix(&matrixB, p, m);

    // 计算乘积矩阵 C
    multiplyMatrix(matrixA, n, p, matrixB, p, m, &matrixC);

    // 输出乘积矩阵 C
    outputMatrix(matrixC, n, m);

    // 释放内存
    free(matrixA);
    free(matrixB);
    free(matrixC);

    return 0;
}

解释：

代码首先包含了 stdio.h 和 stdlib.h 头文件，分别用于标准输入输出和内存分配。
inputMatrix 函数用于输入矩阵，它接受一个指向矩阵指针的指针、矩阵的行数和列数作为参数。函数内部动态分配内存，并使用两重循环输入矩阵元素。
outputMatrix 函数用于输出矩阵，它接受一个指向矩阵的指针、矩阵的行数和列数作为参数。函数内部使用两重循环输出矩阵元素。
multiplyMatrix 函数用于计算矩阵乘积，它接受两个指向矩阵的指针、矩阵的行列数和一个指向结果矩阵指针的指针作为参数。函数内部动态分配内存，并使用三重循环计算矩阵乘积。
main 函数是程序的入口点。它首先读取用户输入的矩阵行列数，然后调用 inputMatrix 函数输入两个矩阵，调用 multiplyMatrix 函数计算乘积矩阵，最后调用 outputMatrix 函数输出乘积矩阵。
最后，在 main 函数结束之前，使用 free 函数释放所有动态分配的内存，以防止内存泄漏。

优化建议：

可以使用更清晰的变量命名，例如将 matrixA、matrixB、matrixC 改为 inputMatrix1、inputMatrix2、resultMatrix 等。
可以将矩阵的输入、输出和计算逻辑封装成独立的函数，以提高代码的可读性和可维护性。
可以添加错误处理，例如在内存分配失败时提示用户并退出程序。
可以使用更有效率的算法，例如 Strassen 矩阵乘法算法，以提高程序的运行效率。

总结：

本代码示例展示了使用 C 语言实现矩阵相乘运算，并使用动态数组分配内存。代码简洁易懂，并注意了内存释放，避免了内存泄漏。可以通过进一步优化代码，使其更清晰、更有效率。