C在结构中初始化数组

Question

我想在结构中包含一个可变长度数组，但无法正确初始化它。

struct Grid {
  int rows;
  int cols;
  int grid[];
}

int main() {
  struct Grid testgrid = {1, 3, {4, 5, 6}};
}

我尝试的每件事都会给我一个“错误：灵活数组成员的非静态初始化”错误。

Answer 1

您可以通过将结构设置为static 或全局结构来使其在 gcc 中工作，但事实证明，初始化灵活数组成员是不符合标准的，因此除了 gcc 之外它可能无法工作。这是一种仅使用符合 C99 的功能的方法...

#include <stdlib.h>
#include <stdarg.h>

typedef struct Grid {
  int rows;
  int cols;
  int grid[];
} *Grid;

Grid newGrid(int, int, ...);

Grid newGrid(int rows, int cols, ...)
{
Grid g;
va_list ap;
int i, n = rows * cols;

  if((g = malloc(sizeof(struct Grid) + rows * cols * sizeof(int))) == NULL)
    return NULL;
  g->rows = rows;
  g->cols = cols;
  va_start(ap, cols);
  for(i = 0; i < n; ++i)
    g->grid[i] = va_arg(ap, int);
  va_end(ap);
  return g;
}
.
.
.
Grid g1, g2, g3;
g1 = newGrid(1, 1, 123);
g2 = newGrid(2, 3, 1, 1, 1,
                   2, 2, 2);
g3 = newGrid(4, 5, 1,  2,  3,  4,  5,
                   6,  7,  8,  9, 10,
                  11, 12, 13, 14, 15,
                  16, 17, 18, 19, 20);

Answer 2

您没有在您的结构中具有可变长度数组 (VLA)。您在结构中拥有的东西称为灵活数组成员。灵活的数组成员与 VLA 完全无关。 C 中存在灵活的数组成员以合法化和支持古老的“struct hack”习语，该习语基于为具有不同大小的尾随数组的结构对象动态分配内存。

灵活的数组成员不能使用聚合初始化器来初始化，这似乎是您在代码中尝试的。您在这里尝试做的事情是根本不可能的。 C中没有这样的功能。

同时，您的编译器生成的错误消息文本似乎表明它支持这样的扩展。这可能是真的，但请记住，这绝不是标准的 C 功能。

Answer 3

这是我的版本：

#include <stdio.h> 

struct matrix {
  int rows;
  int cols;
  int **val;
} a = {        .rows=3,  .cols=1,
        .val = (int*[3]){ (int[1]){1},
                          (int[1]){2},
                          (int[1]){3} } },

  b = {        .rows=3,  .cols=4,
        .val = (int*[3]){ (int[4]){1, 2, 3, 4},
                          (int[4]){5, 6, 7, 8},
                          (int[4]){9,10,11,12} } };

void print_matrix( char *name, struct matrix *m ){
  for( int row=0;row<m->rows;row++ )
    for( int col=0;col<m->cols;col++ )
      printf( "%s[%i][%i]: %i\n", name, row, col, m->val[row][col] );
  puts("");
}

int main(){
  print_matrix( "a", &a );
  print_matrix( "b", &b );
}

Answer 4

我不相信这是可能的或支持的。正如DigitalRoss 指出的那样，您可以在static 数组的情况下从文字初始化......尽管我仍然不确定这是否包含在标准中或只是一个常见的扩展。尽管我可以看到gcc explicitly supports it，但我似乎在标准中找不到支持灵活数组的文字初始化的子句。

Answer 5

使用 malloc 的版本：

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

typedef struct Grid {
  int rows;
  int cols;
  int *grid;
} Grid;

/* Should validate params */
Grid
buildGrid(int rows, int cols, int vec[]) {

    Grid grid;
    grid.rows = rows;
    grid.cols = cols;
    int i;

    if ( (grid.grid = malloc(sizeof(vec))) == NULL ) {
        /* do something.*/
    }

    for(i = 0; i < sizeof(vec) ; i++ ) {
        grid.grid[i] = vec[i];
    }

    return grid;
}