Dynamic memory allocation - Malloc使用错误排查及正确实现咨询

你遇到的输出全0问题，大概率是内存分配方式错误导致的未定义行为——要么是指针类型不匹配，要么是分配的内存大小不足，导致后续赋值和访问操作都在非法内存区域进行。

常见错误示例（你可能的写法） #

比如错误地给double**类型分配了单块double大小的内存，而非指针数组的内存：

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

int main() {
    // 错误：分配的是2个double的内存，不是2个double*指针的内存
    double **d = malloc(2 * sizeof(double));
    // 此处赋值已经是非法内存访问，行为未定义
    d[0][0] = -1.0;
    d[0][1] = 0.0;
    d[1][0] = 1.0;
    d[1][1] = 0.0;

    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            printf("%f\n", d[i][j]);
        }
    }
    free(d);
    return 0;
}

两种正确实现方式 #

方式1：指针数组+独立向量分配

适合需要单独释放某个向量的场景：

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

int main() {
    // 1. 先分配存储2个向量指针的数组
    double **d = malloc(2 * sizeof(double*));
    if (d == NULL) {
        perror("malloc failed for pointer array");
        return 1;
    }

    // 2. 为每个向量分配2个double的内存
    for (int i = 0; i < 2; i++) {
        d[i] = malloc(2 * sizeof(double));
        if (d[i] == NULL) {
            perror("malloc failed for vector");
            // 分配失败时回溯释放已分配的内存，避免泄漏
            for (int j = 0; j < i; j++) {
                free(d[j]);
            }
            free(d);
            return 1;
        }
    }

    // 赋值
    d[0][0] = -1.0;
    d[0][1] = 0.0;
    d[1][0] = 1.0;
    d[1][1] = 0.0;

    // 输出
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            printf("%f\n", d[i][j]);
        }
    }

    // 释放内存：先释放每个向量，再释放指针数组
    for (int i = 0; i < 2; i++) {
        free(d[i]);
    }
    free(d);

    return 0;
}

方式2：连续内存分配（更高效）

如果不需要单独操作单个向量，推荐用这种方式，内存连续且只需一次释放：

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

int main() {
    // 直接分配2个长度为2的double数组的连续内存
    double (*d)[2] = malloc(2 * sizeof(double[2]));
    if (d == NULL) {
        perror("malloc failed");
        return 1;
    }

    // 赋值
    d[0][0] = -1.0;
    d[0][1] = 0.0;
    d[1][0] = 1.0;
    d[1][1] = 0.0;

    // 输出
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            printf("%f\n", d[i][j]);
        }
    }

    // 释放内存
    free(d);

    return 0;
}

关键修正点 #

1. 类型匹配：如果用double**，必须先分配sizeof(double*)的指针数组，再为每个指针分配元素内存；如果用连续内存，要用数组指针double (*d)[2]确保类型正确。
2. 内存大小计算：分配指针数组时，大小是元素个数 * sizeof(指针类型)，而非sizeof(元素类型)。
3. 错误检查：每次调用malloc后都要检查返回值是否为NULL，避免空指针访问；分配失败时要释放已分配的内存，防止内存泄漏。

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