C语言中固定长度不规则二维数组的内存高效存储方案咨询

针对你提出的固定行列数、行长度差异大的二维数组场景，可通过「行信息封装+柔性数组成员」的方案兼顾内存效率和访问便捷性，具体实现如下：

核心结构体定义 #

#include <stdint.h>
#include <stdlib.h>

// 单行列信息：存储当前行列数+列元素首地址
typedef struct {
    uint32_t col_cnt;
    uint32_t* cols;
} jagged_row_t;

// 二维数组总结构：存储行数+行信息柔性数组
typedef struct {
    uint32_t row_cnt;
    jagged_row_t rows[];
} jagged_array_t;

场景1：编译期已知所有行列长度 #

如果行列数、每行长度都是编译期常量，可以直接通过复合字面量静态初始化，完全无内存冗余：

// 静态初始化示例：2行，第0行2个元素，第1行5个元素
static jagged_array_t* arr = &(jagged_array_t) {
    .row_cnt = 2,
    .rows = {
        [0] = {.col_cnt = 2, .cols = (uint32_t[]){7, 17}},
        [1] = {.col_cnt = 5, .cols = (uint32_t[]){100, 2, 5, 12, 4}}
    }
};

如果需要所有元素连续存储提升缓存效率，可以统一管理元素存储区：

// 所有元素连续存储，无碎片化
static uint32_t all_elements[] = {7, 17, 100, 2, 5, 12, 4};
static const uint32_t col_counts[] = {2, 5};
#define TOTAL_ROWS 2

static jagged_array_t* arr = &(jagged_array_t) {
    .row_cnt = TOTAL_ROWS,
    .rows = {
        [0] = {.col_cnt = col_counts[0], .cols = &all_elements[0]},
        [1] = {.col_cnt = col_counts[1], .cols = &all_elements[col_counts[0]]}
    }
};

场景2：运行期动态创建数组 #

如果需要在运行期确定行列长度，可以通过单次malloc分配整块连续内存，释放时只需free一次：

jagged_array_t* create_jagged_array(uint32_t row_cnt, const uint32_t* col_counts) {
    // 计算总元素个数
    uint32_t total_elems = 0;
    for (uint32_t i = 0; i < row_cnt; i++) {
        total_elems += col_counts[i];
    }
    // 一次性分配所有内存：结构体头+行信息数组+元素存储区
    jagged_array_t* arr = malloc(
        sizeof(jagged_array_t) + 
        row_cnt * sizeof(jagged_row_t) + 
        total_elems * sizeof(uint32_t)
    );
    if (!arr) return NULL;

    arr->row_cnt = row_cnt;
    uint32_t* elem_ptr = (uint32_t*)(
        (uint8_t*)arr + sizeof(jagged_array_t) + row_cnt * sizeof(jagged_row_t)
    );
    // 初始化每行的列数和首地址
    for (uint32_t i = 0; i < row_cnt; i++) {
        arr->rows[i].col_cnt = col_counts[i];
        arr->rows[i].cols = elem_ptr;
        elem_ptr += col_counts[i];
    }
    return arr;
}

// 释放内存直接调用free(arr)即可，无需逐行释放

访问和遍历逻辑 #

访问和遍历逻辑和原有方案几乎完全一致，不需要手动计算内存偏移：

// 直接通过下标访问第i行第j个元素
uint32_t val = arr->rows[i].cols[j];

// 遍历逻辑
for (uint32_t i = 0; i < arr->row_cnt; i++) {
    for (uint32_t j = 0; j < arr->rows[i].col_cnt; j++) {
        // 直接操作arr->rows[i].cols[j]即可
    }
}

方案优势 #

• 内存效率拉满：无预分配冗余空间，除了每行8字节的行信息开销，所有空间都用于存储有效数据
• 访问便捷：和原有固定数组的访问逻辑一致，不需要手动计算偏移量
• 缓存友好：动态版本整块分配内存，元素连续存储，CPU缓存命中率远高于逐行malloc的实现
• 适配性强：同时支持编译期静态初始化和运行期动态创建两种场景

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