C语言中如何按输入参数初始化数组并将其设为常量数组？

问题1：根据输入参数将arr0[]和arr1[]初始化为指定数组组 #

C语言里，数组的初始化操作只能在声明时完成，没法在switch分支里直接给数组做初始化赋值。不过我们有几种实用的替代方案可以实现动态切换数组内容的需求：

方案1：使用memcpy复制数组内容 #

这是兼容性最好的方法，支持所有C标准：

#define LENGTH 4
#include <string.h> // 需要包含头文件以使用memcpy

void foo(char id) {
    const char arr_a0[] = {2,1,2,1};
    const char arr_a1[] = {4,5,6,7};
    const char arr_b0[] = {3,3,3,4};
    const char arr_b1[] = {1,5,8,9};
    char arr0[LENGTH];
    char arr1[LENGTH];

    switch(id) {
        case 'a':
            memcpy(arr0, arr_a0, sizeof(arr0));
            memcpy(arr1, arr_a1, sizeof(arr1));
            break;
        case 'b':
            memcpy(arr0, arr_b0, sizeof(arr0));
            memcpy(arr1, arr_b1, sizeof(arr1));
            break;
        default:
            // 处理非法id的情况，比如初始化默认值
            memset(arr0, 0, sizeof(arr0));
            memset(arr1, 0, sizeof(arr1));
            break;
    }
    // 后续正常使用arr0和arr1即可
}

方案2：使用C99复合字面量直接赋值 #

如果你的编译器支持C99或更高标准，可以用复合字面量简化代码，省去单独定义数组的步骤：

#define LENGTH 4

void foo(char id) {
    char arr0[LENGTH];
    char arr1[LENGTH];

    switch(id) {
        case 'a':
            // 通过类型转换直接用复合字面量赋值数组
            * (char (*)[LENGTH])arr0 = (char[LENGTH]){2,1,2,1};
            * (char (*)[LENGTH])arr1 = (char[LENGTH]){4,5,6,7};
            break;
        case 'b':
            * (char (*)[LENGTH])arr0 = (char[LENGTH]){3,3,3,4};
            * (char (*)[LENGTH])arr1 = (char[LENGTH]){1,5,8,9};
            break;
        default:
            // 默认初始化全0
            * (char (*)[LENGTH])arr0 = (char[LENGTH]){0};
            * (char (*)[LENGTH])arr1 = (char[LENGTH]){0};
            break;
    }
}

方案3：使用指针指向常量数组（更高效） #

如果后续不需要修改arr0和arr1的内容，直接用指针指向已定义的常量数组是最高效的，避免了内存复制：

#define LENGTH 4

void foo(char id) {
    const char arr_a0[] = {2,1,2,1};
    const char arr_a1[] = {4,5,6,7};
    const char arr_b0[] = {3,3,3,4};
    const char arr_b1[] = {1,5,8,9};
    const char *arr0;
    const char *arr1;

    switch(id) {
        case 'a':
            arr0 = arr_a0;
            arr1 = arr_a1;
            break;
        case 'b':
            arr0 = arr_b0;
            arr1 = arr_b1;
            break;
        default:
            // 指向默认的常量数组，或处理错误逻辑
            static const char default0[] = {0};
            static const char default1[] = {0};
            arr0 = default0;
            arr1 = default1;
            break;
    }
    // 后续通过指针访问arr0[i]、arr1[i]即可
}

问题2：能否将arr0[]和arr1[]定义为常量数组？ #

可以，但要注意用const修饰的数组一旦声明初始化后就无法修改内容，所以没法在运行时通过赋值切换内容。如果一定要声明为常量数组，只能通过条件编译在编译时确定数组内容（但无法支持运行时动态切换）：

#define LENGTH 4
#define ID 'a' // 编译时指定id值

void foo() {
    #if ID == 'a'
        const char arr0[LENGTH] = {2,1,2,1};
        const char arr1[LENGTH] = {4,5,6,7};
    #elif ID == 'b'
        const char arr0[LENGTH] = {3,3,3,4};
        const char arr1[LENGTH] = {1,5,8,9};
    #else
        const char arr0[LENGTH] = {0};
        const char arr1[LENGTH] = {0};
    #endif
    // 正常使用arr0和arr1
}

这种方法的局限性很大，所以大多数场景下更推荐用方案3的指向常量的指针写法——既保证了数组内容不可修改，又能在运行时根据输入参数动态切换指向的数组。

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