如何通过函数取值声明全局变量？从main函数为全局N、M赋值的方法

嘿，我来帮你搞定这个问题。首先得明确一个C语言的核心限制：全局变量的内存是在程序启动时就分配好的，所以如果你的N和M是从命令行参数这种运行时才能拿到的值，直接声明全局的char board[N][N]这种变长数组（VLA）是不合法的——因为变长数组只能在局部作用域（比如函数内部）使用，全局作用域要求数组大小是编译时就能确定的常量。

那怎么实现你的需求呢？核心思路是用动态内存分配来创建全局可用的二维数组，同时把N和M作为全局变量在main中赋值。下面是具体的实现方案：

方案1：使用二级指针实现动态二维数组 #

这是最常见的方式，灵活且容易理解：

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

// 声明全局变量：N、M作为全局整数，board和game_board作为二级指针
int N, M;
char **board;
char **game_board;

// 示例函数：初始化全局board数组
void init_board() {
    for (int i = 0; i < N; i++) {
        // 初始化每个元素为空格（或你需要的初始值）
        memset(board[i], ' ', N);
        // 设置边界示例
        board[i][0] = board[i][N-1] = '#';
        board[0][i] = board[N-1][i] = '#';
    }
}

// 示例函数：打印全局board数组
void print_board() {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%c ", board[i][j]);
        }
        printf("\n");
    }
}

int main(int argc, char *argv[]) {
    // 先检查命令行参数是否足够
    if (argc < 3) {
        fprintf(stderr, "用法：%s <N> <M>\n", argv[0]);
        return 1;
    }

    // 从命令行获取N和M的值，赋值给全局变量
    N = atoi(argv[1]);
    M = atoi(argv[2]);

    // 动态分配board的内存：先分配N个指向char数组的指针
    board = malloc(N * sizeof(char *));
    if (!board) {
        perror("分配board内存失败");
        return 1;
    }
    // 再为每个指针分配N个char的空间
    for (int i = 0; i < N; i++) {
        board[i] = malloc(N * sizeof(char));
        if (!board[i]) {
            perror("分配board行内存失败");
            // 内存分配失败时，释放已分配的部分避免泄漏
            for (int j = 0; j < i; j++) {
                free(board[j]);
            }
            free(board);
            return 1;
        }
    }

    // 同理分配game_board的内存（逻辑和board一致）
    game_board = malloc(N * sizeof(char *));
    if (!game_board) {
        perror("分配game_board内存失败");
        // 这里要记得释放已分配的board内存，避免泄漏
        for (int j = 0; j < N; j++) {
            free(board[j]);
        }
        free(board);
        return 1;
    }
    for (int i = 0; i < N; i++) {
        game_board[i] = malloc(N * sizeof(char));
        if (!game_board[i]) {
            // 回滚已分配的game_board和board内存
            for (int j = 0; j < i; j++) {
                free(game_board[j]);
            }
            free(game_board);
            for (int j = 0; j < N; j++) {
                free(board[j]);
            }
            free(board);
            return 1;
        }
    }

    // 使用全局变量和数组
    init_board();
    print_board();

    // 程序结束前，释放所有动态分配的内存
    for (int i = 0; i < N; i++) {
        free(board[i]);
        free(game_board[i]);
    }
    free(board);
    free(game_board);

    return 0;
}

方案2：使用指向一维数组的指针实现连续内存的二维数组 #

如果你希望二维数组的内存是连续的（缓存友好，性能更好），可以用指向数组的指针来分配：

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

int N, M;
// 声明全局的指向数组的指针（编译时不指定大小，运行时再绑定）
char (*board_contiguous)[];

// 示例函数：打印连续内存的board
void print_board() {
    // 使用时需要强制转换为对应大小的数组指针
    char (*board)[N] = (char (*)[N])board_contiguous;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%c ", board[i][j]);
        }
        printf("\n");
    }
}

int main(int argc, char *argv[]) {
    if (argc < 3) {
        fprintf(stderr, "用法：%s <N> <M>\n", argv[0]);
        return 1;
    }

    N = atoi(argv[1]);
    M = atoi(argv[2]);

    // 分配连续的N×N的char内存，直接绑定到全局指针
    board_contiguous = malloc(N * sizeof(char[N]));
    if (!board_contiguous) {
        perror("分配内存失败");
        return 1;
    }

    // 初始化整个连续数组
    memset(board_contiguous, ' ', N * N);
    // 设置边界示例
    char (*board)[N] = (char (*)[N])board_contiguous;
    for (int i = 0; i < N; i++) {
        board[i][0] = board[i][N-1] = '#';
        board[0][i] = board[N-1][i] = '#';
    }

    print_board();

    // 释放内存（只需要一次free，因为是连续分配的）
    free(board_contiguous);

    return 0;
}

关键知识点总结 #

• 全局变量可以在函数（比如main）中赋值，这就是你说的“通过函数获取值来声明全局变量”——本质是先声明全局变量，再在函数中给它赋值，毕竟全局变量的声明是编译阶段的事，没法直接用运行时的函数返回值来声明。
• 全局的变长数组是C标准不允许的，所以必须用动态内存分配来实现运行时确定大小的全局可用数组。
• 使用动态内存时，一定要记得在程序结束前释放内存；如果分配过程中失败，要回滚已经分配的内存，避免内存泄漏。

内容的提问来源于stack exchange，提问作者lee shi xuan