C语言函数返回二维数组问题：矩阵自乘结果无法完整返回

问题根源分析 #

你的代码存在三个核心问题：

1. 局部数组内存销毁：函数内的matrixC是栈上的局部数组，函数执行完毕后栈内存会被回收，返回其地址属于未定义行为，后续访问会导致不可预期的错误。
2. 类型不匹配：函数声明返回int**，但实际返回的*ptr是int类型（matrixC[0][0]的值），编译器会抛出类型不兼容的警告或错误。
3. 赋值方式错误：main中用**result = multiplyMatrix(...)仅对result[0][0]赋值，完全没有处理矩阵的其他元素，所以其余位置保持初始的0值。

方案一：传入结果数组直接修改（推荐） #

最稳妥且高效的方式是让调用者提前分配好结果数组，作为参数传入函数，函数直接在该数组上完成计算，避免内存管理问题。

修改后的乘法函数

void multiplyMatrix(int matrixA[10][10], int matrixB[10][10], int result[10][10], int n)
{
    // 先初始化结果数组为0
    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            result[row][col] = 0;
        }
    }

    // 矩阵乘法核心计算
    for (int rowC = 0; rowC < n; rowC++)
    {
        for (int columnC = 0; columnC < n; columnC++)
        {
            for (int i = 0; i < n; i++)
            {
                result[rowC][columnC] += matrixA[rowC][i] * matrixB[i][columnC];
            }
        }
    }
}

对应的main函数调用

int main() // 标准C规定main函数返回类型为int，而非void
{
    int n = 2;
    int matrixA[10][10] = { 0 };
    int result[10][10] = { 0 };
    
    setMatrix(matrixA, n);
    printMatrix(matrixA, n);

    // 直接传入result数组，函数会填充计算结果
    multiplyMatrix(matrixA, matrixA, result, n);
    printMatrix(result, n);

    return 0; // 标准main函数需要返回值
}

方案优势

• 完全避免局部变量销毁导致的野指针问题，内存安全。
• 无需动态分配内存，省去内存释放的繁琐步骤。
• 逻辑清晰，调用者明确知道结果存储位置。

方案二：动态分配内存返回（需手动释放） #

如果必须让函数返回矩阵，可以通过动态分配堆内存实现，但要注意手动释放内存，避免泄漏。

修改后的乘法函数

#include <stdlib.h>
#include <string.h>

int** multiplyMatrix(int matrixA[10][10], int matrixB[10][10], int n)
{
    // 动态分配行指针数组
    int** result = malloc(n * sizeof(int*));
    if (result == NULL) {
        return NULL; // 内存分配失败，返回空指针
    }

    // 为每一行分配内存并初始化
    for (int i = 0; i < n; i++) {
        result[i] = malloc(n * sizeof(int));
        if (result[i] == NULL) {
            // 分配失败时，释放已分配的内存避免泄漏
            for (int j = 0; j < i; j++) {
                free(result[j]);
            }
            free(result);
            return NULL;
        }
        memset(result[i], 0, n * sizeof(int));
    }

    // 矩阵乘法核心计算
    for (int rowC = 0; rowC < n; rowC++)
    {
        for (int columnC = 0; columnC < n; columnC++)
        {
            for (int i = 0; i < n; i++) {
                result[rowC][columnC] += matrixA[rowC][i] * matrixB[i][columnC];
            }
        }
    }

    return result;
}

对应的main函数调用

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

int main()
{
    int n = 2;
    int matrixA[10][10] = { 0 };
    int** result;
    
    setMatrix(matrixA, n);
    printMatrix(matrixA, n);

    result = multiplyMatrix(matrixA, matrixA, n);
    if (result != NULL) {
        // 打印结果（需适配int**类型，或修改printMatrix函数）
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                printf("%d ", result[i][j]);
            }
            printf("\n");
        }

        // 必须手动释放内存，避免泄漏
        for (int i = 0; i < n; i++) {
            free(result[i]);
        }
        free(result);
    }

    return 0;
}

方案注意点

• 必须在使用完矩阵后手动释放内存，否则会造成内存泄漏。
• 需要修改printMatrix函数以支持int**类型，或者手动遍历打印。
• 内存分配可能失败，需添加错误判断逻辑。

内容的提问来源于stack exchange，提问作者Snafuzila