A question about specifying the *shape* of an array of pointers in C

I'm building a system in C that will be handling three-dimensional arrays. For our toy example here these have the shape 3x3x2. We think of them as two-dimensionals 3x3 grids where each cell holds an array of data.

At times I will want to access certain subparts of such a grid; in particular I will want to get access to the rows and diagonals of the grid. More specifically, given an array of coordinate pairs I want to get a pointer to an array that contains pointers to the contents of those cells. This I've been able to do with my function subfinder, see the code below.

#include <stdio.h>

typedef char mygrid[3][3][2];
typedef char** subthing;

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;
    }

    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 = subfinder(example_grid, diag_indeces);
    printf("Diagonal is        (%d, %d).\n", diagonal[1][0], diagonal[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[1][0], diagonal[1][1]);

    diagonal[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[1][0], diagonal[1][1]);
}

What my problem here is that I would like to have my typedef of subthing to be more descriptive of the fact that the thing it points to always has the shape of 3x2, or even that it has length 3. (I'm always getting either rows or diagonals from the main grid here.) So instead of typedef char** subthing; I would like to say e.g. typedef char* subthing[3]; But the latter fails to compile with function type definition errors shown at the end. What I fail to understand is why inside the subfinder function I can declare the thing to be returned as static char* result_array[3];, but this cannot then be used as the return type of the function itself.

Any help or explanations about what I'm doing here would be much appreciated!

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);
^~~~~~~~~

One possible idea is to avoid returning the array as an object, but rather having it passed as an argument, and fill it inside the function. You can even typedef it as you want.

#include <stdio.h>

/*
Original center is (2, 2).
Diagonal is        (2, 2).
Original center is (7, 8).
Diagonal is        (7, 8).
Original center is (0, 8).
Diagonal is        (0, 8).
*/

typedef char mygrid[3][3][2];
typedef char* subthing_type[3];

void subfinder(mygrid p_grid, int indeces[3][2], subthing_type subthing) {
    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];
        subthing[i] = new;
    }

}

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_type diagonal;
    subfinder(example_grid, diag_indeces,diagonal);
    printf("Diagonal is        (%d, %d).\n", diagonal[1][0], diagonal[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[1][0], diagonal[1][1]);

    diagonal[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[1][0], diagonal[1][1]);
}

You can go all in and pass only fully typed variables. Normally, as you are aware, arrays are "adjusted" to pointers to their first element when they are passed as arguments. This is the reason for the information loss you are lamenting: The array length is lost in transition. We can prevent this by passing pointers to arrays. The pointer retains its complete type information through assignments and as a function argument (the two have similar semantics). This makes it possible for the compiler to warn about out-of-bounds access, for example if you comment the printf at the end of subfinder() in.

The downside is that you have to dereference the pointer-to-array before you index it. This complicates expressions, especially if the array elements in turn are pointers to arrays, as is the case with diagonal in main().

Pointers to arrays are peculiar in that they have the same numeric value as the first element. The only difference is the type. This makes a difference when that pointer is incremented or indexed: Because each element pointed to is the entire array its "unit" is the entire array size (not the array element size).

Note that this is not very idiomatic C, and I'm not really recommending it. (I'd also think that Dennis Ritchie didn't consider this idiomatic or he would have exchanged the precedence of the index operator [] and the dereference operator *.) The expressions become unwieldy and hard to parse (I just stared 10 minutes at my code because I made an error bracketing (*(*diagonal)[0])[0] correctly). It is also only possible if the array dimensions are known at compile time. But here is a fully typed solution anyway. I used symbolic constants for your dimensions and typedef'ed as much as I could but you should recognize most of the code.

#include <stdio.h>
#define X_DIM 3
#define Y_DIM 3
#define CELL_SZ 2
#define IDX_ARR_LEN 3 // not the same as X or Y_DIM!
typedef char CELL[CELL_SZ];          // the basic unit, a char pair.
typedef CELL MYGRID[X_DIM][Y_DIM];   // it's a 2-dimensional grid of cells, as you explained
typedef CELL *CELLPTR_ARR[IDX_ARR_LEN]; // IDX_ARR_LEN pointers to cells
typedef int IDX_ARR[IDX_ARR_LEN][2];     // the 2 is unrelated to CELL_SZ (it's x and y)
CELLPTR_ARR *subfinder(MYGRID *p_grid, IDX_ARR *idxArr) {
static CELLPTR_ARR result_array;
int x, y;
for (int i = 0; i < IDX_ARR_LEN; i++) {
x = (*idxArr)[i][0];
y = (*idxArr)[i][1];
CELL *addr = &(*p_grid)[x][y];
result_array[i] = addr;
}
// Advantage: array out-of-bounds warning.
// printf("%d\n", (*idxArr)[IDX_ARR_LEN][0]);
return &result_array;
}
char diagValAt(CELLPTR_ARR* cellPtrArrPtr, int arrIdx, int cellIdx)
{
return (*(*cellPtrArrPtr)[arrIdx])[cellIdx];
}
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]);
IDX_ARR diag_indeces = { {0,0}, {1,1}, {2,2} };
CELLPTR_ARR *diagonal = subfinder(&example_grid, &diag_indeces);
printf("Diagonal is        (%d, %d).\n", (*(*diagonal)[0])[0], (*(*diagonal)[0])[1]);
printf("                   (%d, %d).\n", (*(*diagonal)[1])[0], (*(*diagonal)[1])[1]);
printf("                   (%d, %d).\n", (*(*diagonal)[2])[0], (*(*diagonal)[2])[1]);
// Changing center cell to 7/8
example_grid[1][1][0] = 7;
example_grid[1][1][1] = 8;
printf("Center is (%d, %d).\n", example_grid[1][1][0], example_grid[1][1][1]);
printf("Diagonal is        (%d, %d).\n", (*(*diagonal)[0])[0], (*(*diagonal)[0])[1]);
printf("                   (%d, %d).\n", (*(*diagonal)[1])[0], (*(*diagonal)[1])[1]);
printf("                   (%d, %d).\n", (*(*diagonal)[2])[0], (*(*diagonal)[2])[1]);
// Changing middle cell's first elem to 0 through diagonal
(*(*diagonal)[1])[0] = 0;
printf("Original center is (%d, %d).\n", example_grid[1][1][0], example_grid[1][1][1]);
printf("Diagonal center is (%d, %d).\n", (*(*diagonal)[1])[0], (*(*diagonal)[1])[1]);
// the proper bracketing of the diagonal access gave me a headache.
// Of course, one could brake it down into steps:
// diagonal is a pointer to a subthing; de-referenced, it is an array of pointers to cell; 
// assigned, it is adjusted to a pointer to its first element
CELL** cellPtrArr = *diagonal;
CELL* cellPtr = cellPtrArr[1]; // middle
char* cell = *cellPtr;
printf("%d %d\n", cell[0], cell[1]);
// Or you turf it to a function you never look at again once it's tested.
printf("%d %d\n", diagValAt(diagonal,1,0), diagValAt(diagonal,1,1));
}