C语言动态扩容二维数组出现段错误，如何优化实现？

你的函数出现段错误和内存问题主要有几个核心原因：

• 传参方式错误：函数参数size_t **trips是传值调用，realloc修改的是形参的地址，实参根本不会更新。当realloc返回新地址时，原实参还是旧的指针，不仅会内存泄漏，后续操作还会访问无效内存。
• 未初始化新行指针：扩容行之后，trips[dim-1]是一个未初始化的野指针，直接去赋值trips[dim-1][j] = 0必然触发段错误。
• 错误的内存分配检查逻辑：realloc失败时返回NULL，但你只检查errno，这不可靠——realloc成功时不会重置errno，如果之前有其他操作设置了errno，会导致误判。
• 循环变量类型不匹配：i,j用int类型，但dim是size_t（无符号整数），当dim超过int的范围时，会出现循环条件错误。

修复后的函数代码 #

我们把参数改成指针的指针，确保实参能被正确更新，同时修正内存分配和初始化的顺序：

#include <stdlib.h>
#include <errno.h>

static int enlargeTrips(size_t ***trips, size_t dim)
{
    // 先扩容行指针数组
    size_t **new_trips = realloc(*trips, dim * sizeof(size_t *));
    if (new_trips == NULL) {
        return ENOMEM; // 返回错误码，让调用者处理
    }
    *trips = new_trips;

    // 为新行分配内存并初始化为0
    size_t *new_row = calloc(dim, sizeof(size_t));
    if (new_row == NULL) {
        return ENOMEM;
    }
    (*trips)[dim - 1] = new_row;

    // 扩容每一行的列数，新增的列设为0
    for (size_t i = 0; i < dim - 1; i++) {
        size_t *new_col = realloc((*trips)[i], dim * sizeof(size_t));
        if (new_col == NULL) {
            // 内存分配失败，回滚已分配的新行
            free(new_row);
            return ENOMEM;
        }
        (*trips)[i] = new_col;
        // 新列初始化为0
        (*trips)[i][dim - 1] = 0;
    }

    return 0; // 成功
}

修复点说明 #

1. 传参改为size_t ***trips：通过指针的指针，让函数能修改外部的trips指针，确保实参同步更新。
2. 用calloc初始化新行：calloc会直接把内存填充为0，省去手动循环赋值的麻烦，同时避免访问野指针。
3. 正确检查realloc返回值：直接判断返回值是否为NULL，这是标准的内存分配失败检查方式。
4. 添加错误回滚：如果中间某行扩容失败，释放已分配的新行，避免内存泄漏。
5. 循环变量用size_t：和dim类型匹配，避免溢出问题。
6. 返回错误码：让调用者能感知到内存分配失败，而不是默默返回。

更优的实现方式：单块内存分配二维数组 #

上面的方式是“数组的数组”，每行内存是分散的，容易产生内存碎片，访问效率也不如连续内存。如果你的二维数组是规则的（每行列数相同），可以用单块内存分配，更高效：

#include <stdlib.h>

typedef struct {
    size_t rows;
    size_t cols;
    size_t *data; // 连续存储所有元素
} TripMatrix;

static int enlargeTripMatrix(TripMatrix *matrix)
{
    size_t new_rows = matrix->rows + 1;
    size_t new_cols = matrix->cols + 1;

    // 重新分配连续内存：new_rows * new_cols 个元素
    size_t *new_data = realloc(matrix->data, new_rows * new_cols * sizeof(size_t));
    if (new_data == NULL) {
        return ENOMEM;
    }

    // 初始化新增的行和列
    // 先填充新增的列（原每行的最后一个位置）
    for (size_t i = 0; i < matrix->rows; i++) {
        new_data[i * new_cols + new_cols - 1] = 0;
    }
    // 填充新增的整行
    size_t start = matrix->rows * new_cols;
    for (size_t j = 0; j < new_cols; j++) {
        new_data[start + j] = 0;
    }

    matrix->data = new_data;
    matrix->rows = new_rows;
    matrix->cols = new_cols;

    return 0;
}

// 初始化矩阵
static TripMatrix initTripMatrix(void)
{
    TripMatrix m = {0};
    return m;
}

// 访问元素的宏
#define MATRIX_AT(m, row, col) ((m)->data[(row) * (m)->cols + (col)])

优势 #

• 内存连续：所有元素存在一块内存里，缓存命中率更高，访问速度更快。
• 减少内存分配次数：只需要一次realloc，避免多次分配带来的开销和碎片。
• 更容易管理：只需要释放一次data指针即可，不会出现漏释放某行的情况。

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