如何用malloc分配可通过下标访问的动态矩阵并实现函数式风格操作

完全理解你的需求——摆脱固定数组和繁琐的输入输出参数，用更函数式的方式处理矩阵，同时还能像普通二维数组那样用mat[x][y]访问元素，这在C语言里完全可以做到！核心思路就是用**动态内存分配（malloc）**创建可在函数外存活的矩阵，再通过封装结构体来携带矩阵的行列信息，让每个操作都返回新的矩阵实例，避免副作用。

第一步：定义矩阵结构体 #

首先我们需要一个结构体来封装矩阵的行列数和数据指针，这样函数返回的时候能把矩阵的完整信息带回来，也方便后续操作：

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

// 封装矩阵的结构体，携带行列信息和数据指针
typedef struct {
    int rows;
    int cols;
    int** data;  // 指向指针数组的指针，支持二维下标访问
} Matrix;

这里的int** data就是实现mat.data[x][y]访问的关键——它本质是一个数组，每个元素指向一行的int数组，所以我们可以像操作普通二维数组那样用下标访问。

第二步：实现核心函数 #

接下来我们逐个实现你需要的操作：创建矩阵、输入矩阵、矩阵加法、打印矩阵，以及最重要的内存释放（避免泄漏）。

1. 创建空矩阵（分配内存） #

这个函数负责为矩阵分配内存，后续可以用来填充数据或者作为运算结果的容器：

Matrix create_empty_matrix(int rows, int cols) {
    Matrix mat;
    mat.rows = rows;
    mat.cols = cols;

    // 先分配行指针数组
    mat.data = (int**)malloc(rows * sizeof(int*));
    if (mat.data == NULL) {
        fprintf(stderr, "内存分配失败！\n");
        exit(EXIT_FAILURE);
    }

    // 为每一行分配列空间
    for (int i = 0; i < rows; i++) {
        mat.data[i] = (int*)malloc(cols * sizeof(int));
        if (mat.data[i] == NULL) {
            fprintf(stderr, "内存分配失败！\n");
            // 已分配的内存要提前释放，避免泄漏
            for (int j = 0; j < i; j++) {
                free(mat.data[j]);
            }
            free(mat.data);
            exit(EXIT_FAILURE);
        }
    }

    return mat;
}

2. 输入矩阵数据 #

这个函数创建矩阵并从标准输入读取元素，直接返回填充好的矩阵：

Matrix input_matrix() {
    int rows, cols;
    printf("请输入矩阵的行数和列数：");
    scanf("%d %d", &rows, &cols);

    Matrix mat = create_empty_matrix(rows, cols);

    printf("请输入矩阵元素（共%d个）：\n", rows * cols);
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            scanf("%d", &mat.data[i][j]);
        }
    }

    return mat;
}

3. 矩阵加法（函数式风格：返回新矩阵，不修改输入） #

函数式的关键就是不修改原始输入，而是创建并返回一个全新的结果矩阵：

Matrix matrix_add(Matrix a, Matrix b) {
    // 先检查两个矩阵是否可以相加
    if (a.rows != b.rows || a.cols != b.cols) {
        fprintf(stderr, "矩阵行列数不匹配，无法相加！\n");
        exit(EXIT_FAILURE);
    }

    // 创建空矩阵存储结果
    Matrix result = create_empty_matrix(a.rows, a.cols);

    // 遍历元素相加
    for (int i = 0; i < a.rows; i++) {
        for (int j = 0; j < a.cols; j++) {
            result.data[i][j] = a.data[i][j] + b.data[i][j];
        }
    }

    return result;
}

4. 打印矩阵 #

这个函数负责输出矩阵内容，不需要返回值：

void print_matrix(Matrix mat) {
    printf("矩阵内容：\n");
    for (int i = 0; i < mat.rows; i++) {
        for (int j = 0; j < mat.cols; j++) {
            printf("%d ", mat.data[i][j]);
        }
        printf("\n");
    }
}

5. 释放矩阵内存 #

动态分配的内存必须手动释放，这个函数负责完整释放矩阵的所有内存：

void free_matrix(Matrix mat) {
    for (int i = 0; i < mat.rows; i++) {
        free(mat.data[i]);  // 先释放每一行的列内存
    }
    free(mat.data);        // 再释放行指针数组
    // 结构体本身是栈上分配的，不需要free，如果是malloc的结构体才需要
}

第三步：使用示例 #

最后我们用main函数来演示整个流程，完全符合函数式的调用风格：

int main() {
    // 输入两个矩阵
    Matrix mat1 = input_matrix();
    Matrix mat2 = input_matrix();

    // 矩阵加法，返回新矩阵
    Matrix sum = matrix_add(mat1, mat2);

    // 打印结果
    print_matrix(sum);

    // 释放所有动态内存
    free_matrix(mat1);
    free_matrix(mat2);
    free_matrix(sum);

    return 0;
}

为什么这是函数式风格？ #

• 无副作用：所有操作都不会修改输入的矩阵，而是返回全新的结果矩阵
• 避免IO参数：不需要把矩阵作为输出参数传入函数，直接返回结果，代码更简洁
• 纯函数特性：相同的输入一定会得到相同的输出，没有外部状态影响

这样实现后，你不仅可以用mat.data[x][y]访问元素，还能灵活处理任意大小的矩阵，完全摆脱固定数组的限制。

内容的提问来源于stack exchange，提问作者galex-713