C语言中如何创建列数未知的7行矩阵存储规则生成的表格数据

核心思路 #

C语言无法直接声明列数不固定的静态二维数组，因此采用指针数组+动态内存分配的方案：

• 先计算每个表格的元素总数，确定每行所需内存大小
• 为每行单独分配对应容量的内存
• 将原有的打印逻辑改为向数组写入数据

步骤实现 #

1. 辅助函数：计算每个表格的元素数量 #

先实现一个函数统计每行的元素个数，避免重复计算逻辑：

int count_table_elements(int table_num) {
    if (table_num == 7) {
        // Table7：从64到100，共37个数字
        return 100 - 64 + 1;
    }
    int start = 1 << (table_num - 1); // 用位运算替代pow(2, n)，避免浮点数精度问题
    int step = 1 << table_num;        // 显示+跳过的总步长：2^table_num
    int count = 0;
    int current = start;
    
    while (current <= 100) {
        int display_count = start;
        // 最后一段可能不足start个，取剩余数字数
        if (current + display_count - 1 > 100) {
            display_count = 100 - current + 1;
        }
        count += display_count;
        current += step;
    }
    return count;
}

2. 创建动态矩阵并填充数据 #

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

int count_table_elements(int table_num) {
    if (table_num == 7) {
        return 100 - 64 + 1;
    }
    int start = 1 << (table_num - 1);
    int step = 1 << table_num;
    int count = 0;
    int current = start;
    
    while (current <= 100) {
        int display_count = start;
        if (current + display_count - 1 > 100) {
            display_count = 100 - current + 1;
        }
        count += display_count;
        current += step;
    }
    return count;
}

int main() {
    // 声明指针数组，每个元素指向一行的首地址
    int *matrix[7];
    // 记录每行的元素个数，方便后续遍历
    int row_sizes[7];

    // 为每行分配内存并填充数据
    for (int table_num = 1; table_num <= 7; table_num++) {
        int row_idx = table_num - 1;
        row_sizes[row_idx] = count_table_elements(table_num);
        
        // 分配对应大小的内存
        matrix[row_idx] = (int *)malloc(row_sizes[row_idx] * sizeof(int));
        if (matrix[row_idx] == NULL) {
            printf("内存分配失败\n");
            return 1;
        }

        int elem_idx = 0; // 当前行的元素索引
        if (table_num == 7) {
            // 处理Table7
            for (int num = 64; num <= 100; num++) {
                matrix[row_idx][elem_idx++] = num;
            }
        } else {
            int start = 1 << (table_num - 1);
            int step = 1 << table_num;
            int display_count = start;
            
            for (int num = start; num <= 100; num += step) {
                // 写入当前段的数字
                for (int i = 0; i < display_count; i++) {
                    int current_num = num + i;
                    if (current_num > 100) break;
                    matrix[row_idx][elem_idx++] = current_num;
                }
            }
        }
    }

    // 测试输出矩阵内容
    for (int i = 0; i < 7; i++) {
        printf("Table %d:\n", i + 1);
        for (int j = 0; j < row_sizes[i]; j++) {
            printf("%3d ", matrix[i][j]);
            // 每10个数字换行，提升可读性
            if ((j + 1) % 10 == 0) printf("\n");
        }
        printf("\n\n");
        // 使用完后释放内存，避免泄漏
        free(matrix[i]);
    }

    return 0;
}

关键细节说明 #

• 位运算替代pow：pow(2, n)返回浮点数，可能出现精度误差（比如pow(2,6)可能返回63.999999，转int后变成63），用1 << n做整数运算更高效准确。
• 内存管理：动态分配的内存必须用free释放，否则会造成内存泄漏。
• row_sizes数组：记录每行的元素数量，是遍历矩阵的必要依据，因为无法通过指针直接获取动态数组的长度。

替代方案：连续内存的二维动态数组 #

如果需要整个矩阵在内存中连续存储，可以用以下方式（复杂度稍高，日常场景推荐指针数组方案）：

// 先计算总元素数
int total_elements = 0;
for (int i = 0; i < 7; i++) {
    total_elements += row_sizes[i];
}
// 分配连续内存
int *matrix = (int *)malloc(total_elements * sizeof(int));
// 通过偏移量访问每行：第i行起始位置 = matrix + 前i行元素总数之和

内容的提问来源于stack exchange，提问作者Ravened-Clock