Initializing variable size arrays in C

You can make member y a pointer to incomplete array type.

typedef struct {
  ...
  int       (*y)[]; // a pointer an array of unspecified length
} xy_t;

This would let initialize y with a compound literal.

xy_t xy;
xy.y = (int[3][2]){{0,0}, {0,0}, {0,0}};

However it will not be possible to dereference this 2D array because the type of xy.y is incomplete. This can be solved by assigning this pointer to a pointer to VLA with completed type.

int (*arr)[xy.N] = xy.y;

arr[i][j] = 42;

int** is no longer a 2d array; it's a pointer to a pointer, or more specifically a pointer to an array of pointers in our case.

That's why you are having problems assigning a pointer to a 2d array ((int[3][2]){{0,0}, {0,0}, {0,0}}) to it.

To initialize int**, you would need something like

xy_t xy = {
   .M = 3,
   .N = 2,
   .x = (int[3]){ 0,0,0 },
   .y = (int*[3]){
      (int[2]){ 0,0 },
      (int[2]){ 0,0 },
      (int[2]){ 0,0 },
   },
};

You can also let the compiler do the counting:

xy_t xy = {
   .M = 3,
   .N = 2,
   .x = (int[]){ 0,0,0 },
   .y = (int*[]){
      (int[]){ 0,0 },
      (int[]){ 0,0 },
      (int[]){ 0,0 },
   },
};

Despite not being a 2d array, you can still access y[i][j] using
xy.y[ i ][ j ].

The above structure needs M+2 pointers and M+3 memory blocks. If you wanted to make the structure smaller, you could use the following which only uses 2 pointers and 3 memory blocks:

typedef struct {
  const int M;
  const int N;
  int       *x;   // Should be 1-D M elements
  int       *y;   // 2-D M*N elements
} xy_t;

xy_t xy = {
   .M = 3,
   .N = 2,
   .x = (int[]){ 0,0,0 },
   .y = (int[]){ 0,0, 0,0, 0,0 },
};

You would access y[i][j] using xy.y[ i * xy.N + j ].

You could also cast it to a pointer to a 2d array in order to use y[i][j]. This is done as follows:

int (*y)[ xy.M ][ xy.N ] = (int(*)[ xy.M ][ xy.N ])xy.y;

You can make it even smaller! The following uses zero pointers and just one memory block.

typedef struct {
  const int M;
  const int N;
  int xy[];
} xy_t;

xy_t xy = {
   .M = 3,
   .N = 2,
   .xy = {
       0,0,0,
       0,0, 0,0, 0,0
   },
};

You would access x[i] using xy.xy[ i ].<br>
You would access y[i][j] using xy.xy[ xy.M + i * xy.N + j ].

Or:

int (*x)[ xy.M ]         = (int(*)[ xy.M ])xy.xy;
int (*y)[ xy.M ][ xy.N ] = (int(*)[ xy.M ][ xy.N ])( xy.xy + xy.M );

x[i]
y[i][j]

That said, gcc warns

> warning: initialization of a flexible array member [-Wpedantic]

So this last solution is probably non-standard.

If you want to initialize x and y with zeros, you can create a function that initializes them using malloc.

typedef struct {
  const int M;
  const int N;
  int      *x;  // 1-D M elements
  int      *y;  // 2-D M*N elements
} xy_t;

void init_arrays(xy_t *xy){
    int *new_x = malloc(sizeof(int)*(xy->M));
    for (int i = 0; i < xy->M; i++) {
        new_x[i] = 0;
    }
    xy->x = new_x;

    int *new_y = malloc(sizeof(int)*(xy->M*xy->N));
    for (int i = 0; i < xy->M; i++) {
        for (int j = 0; j < xy->N; j++) {
            new_y[i*xy->N + j] = 0;
        }
    }
    xy->y = new_y;
}

This is an example, you may prefer to create a constructor like that : xy_t *new_xy_t(int M, int N), both can work.

NB:

• y has become 1-D, the 2-D is artificially created by i*xy->M + j (as klutt mentioned), it makes it safer to manipulate. You can create a getter and a setter to access numbers more easily.
• Since we used dynamic allocation, this has to come with a free function (as no more sigsev mentioned).

There is no easy way in C. There is no easy way even in C++
You will have to either:

1. Declare somewhere fully initialized two-dimensional array and then use its name as the initalizer for your .y.
2. Almost same, but with malloc of primary dimension (array of pointers) and another malloc (or multiple) for secondary dimension (each pointer in the array of pointers). This is what Tristan Riehs proposed above.

However if you are ready to give up on resizibility of both dimensions, you can use macro to simulate templates of C++, so that each concrete instance of your struct will be with fixed 2nd dimension.