C语言指定指针数组形状问题：typedef返回数组编译报错咨询

问题背景 #

我正在用C语言构建一个处理三维数组的系统，示例中数组形状为3x3x2，可视为每个单元格存储数据数组的3x3二维网格。需要通过subfinder函数获取网格的行或对角线子部分，即根据坐标数组返回指向单元格内容指针的数组。目前使用typedef char** subthing;可实现功能，但希望将subthing定义为typedef char* subthing[3];以体现其长度为3的特性，却出现编译报错。

编译错误信息 #

gcc errors:
test.c:6:10: error: ‘subfinder’ declared as function returning an array
 subthing subfinder(mygrid p_grid, int indeces[3][2]) {
          ^~~~~~~~~
test.c: In function ‘subfinder’:
test.c:18:12: warning: return makes integer from pointer without a cast [-Wint-conversion]
     return result_array;
            ^~~~~~~~~~~~
test.c: In function ‘main’:
test.c:30:25: error: invalid initializer
     subthing diagonal = subfinder(example_grid, diag_indeces);
                         ^~~~~~~~~

错误原因 #

C语言语法明确限制：函数不能直接返回数组类型，具体对应错误的原因如下：

1. 当用typedef char* subthing[3];定义类型时，subthing本质是长度为3的char*数组类型，而C不允许函数声明为返回数组类型，直接触发第一个编译错误。
2. 函数内的static char* result_array[3];是合法的局部静态数组，但返回result_array时，数组名会隐式退化为指向首元素的指针（即char**类型），但函数声明的返回类型是数组，编译器无法完成指针到数组的类型转换，因此出现“返回值将指针转为整数”的警告。
3. 在main中，试图用函数返回值初始化subthing类型的数组变量，但函数返回的是指针，数组不能用指针直接初始化，触发第三个错误。

解决方案 #

针对需求，有两种可行的修改方案：

方案1：使用指向固定长度数组的指针作为返回类型 #

将subthing定义为指向长度为3的char*数组的指针，既保留数组长度的类型信息，又符合C语言的返回规则：

#include <stdio.h>

typedef char mygrid[3][3][2];
// 定义为指向长度为3的char*数组的指针
typedef char* (*subthing)[3];

subthing subfinder(mygrid p_grid, int indeces[3][2]) {
    static char* result_array[3];
    int x, y;

    for(int i=0; i<3; i++) {
        x = indeces[i][0];
        y = indeces[i][1];

        char* new = p_grid[x][y];
        result_array[i] = new;
    }

    // 返回数组的地址，匹配subthing类型
    return &result_array;
}

int main() {
    mygrid example_grid = {
            { {1, 1}, {1, 2}, {1, 3} }, 
            { {2, 1}, {2, 2}, {2, 3} }, 
            { {3, 1}, {3, 2}, {3, 3} }
        }; 
    printf("Original center is (%d, %d).\n", example_grid[1][1][0], example_grid[1][1][1]);

    int diag_indeces[3][2] = {{0,0}, {1,1}, {2,2}};
    // 使用指针访问数组
    subthing diagonal_ptr = subfinder(example_grid, diag_indeces);
    printf("Diagonal is        (%d, %d).\n", (*diagonal_ptr)[1][0], (*diagonal_ptr)[1][1]);

    example_grid[1][1][0] = 7;
    example_grid[1][1][1] = 8;
    printf("Original center is (%d, %d).\n", example_grid[1][1][0], example_grid[1][1][1]);
    printf("Diagonal is        (%d, %d).\n", (*diagonal_ptr)[1][0], (*diagonal_ptr)[1][1]);

    (*diagonal_ptr)[1][0] = 0;
    printf("Original center is (%d, %d).\n", example_grid[1][1][0], example_grid[1][1][1]);
    printf("Diagonal is        (%d, %d).\n", (*diagonal_ptr)[1][0], (*diagonal_ptr)[1][1]);
}

方案2：将数组包装在结构体中返回 #

C语言允许函数返回结构体类型，把长度为3的char*数组包装到结构体里，既保留长度信息，又能直接返回：

#include <stdio.h>

typedef char mygrid[3][3][2];
// 用结构体包装固定长度数组
typedef struct {
    char* arr[3];
} subthing;

subthing subfinder(mygrid p_grid, int indeces[3][2]) {
    subthing result;
    int x, y;

    for(int i=0; i<3; i++) {
        x = indeces[i][0];
        y = indeces[i][1];

        result.arr[i] = p_grid[x][y];
    }

    return result;
}

int main() {
    mygrid example_grid = {
            { {1, 1}, {1, 2}, {1, 3} }, 
            { {2, 1}, {2, 2}, {2, 3} }, 
            { {3, 1}, {3, 2}, {3, 3} }
        }; 
    printf("Original center is (%d, %d).\n", example_grid[1][1][0], example_grid[1][1][1]);

    int diag_indeces[3][2] = {{0,0}, {1,1}, {2,2}};
    subthing diagonal = subfinder(example_grid, diag_indeces);
    printf("Diagonal is        (%d, %d).\n", diagonal.arr[1][0], diagonal.arr[1][1]);

    example_grid[1][1][0] = 7;
    example_grid[1][1][1] = 8;
    printf("Original center is (%d, %d).\n", example_grid[1][1][0], example_grid[1][1][1]);
    printf("Diagonal is        (%d, %d).\n", diagonal.arr[1][0], diagonal.arr[1][1]);

    diagonal.arr[1][0] = 0;
    printf("Original center is (%d, %d).\n", example_grid[1][1][0], example_grid[1][1][1]);
    printf("Diagonal is        (%d, %d).\n", diagonal.arr[1][0], diagonal.arr[1][1]);
}

方案对比 #

• 方案1使用指针，和原代码的static数组逻辑一致，返回的是静态数组的地址，修改返回值会直接修改静态数组内容。
• 方案2使用结构体返回值，是值拷贝，结构体中的数组是独立副本，但由于存储的是指针，指向的仍是原三维数组的单元格，修改指针指向的内容仍会影响原数组。

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