在 C 中使用灵活的数组成员是不好的做法吗？

Question

我最近读到，在 C 中使用灵活的数组成员是糟糕的软件工程实践。 然而，该声明没有得到任何论据的支持。 这是一个公认的事实吗？

（灵活数组成员是 C99 中引入的一项 C 功能，可以将最后一个元素声明为未指定大小的数组，例如：）

struct header {
    size_t len;
    unsigned char data[];
};

Answer 1

使用 goto 是糟糕的软件工程实践，这是一个公认的“事实”。 但这并不代表它是真的。 有时 goto 很有用，特别是在处理清理和从汇编程序移植时。

灵活的数组成员让我印象深刻，因为它有一个主要用途，即映射传统数据格式，例如 RiscOS 上的窗口模板格式。 大约 15 年前，它们对此非常有用，而且我确信仍然有人在处理此类事情，他们会发现它们很有用。

如果使用灵活的数组成员是不好的做法，那么我建议我们都去告诉 C99 规范的作者这一点。 我怀疑他们可能有不同的答案。

Answer 2

不，在 C 中使用灵活数组成员并不是一个坏习惯。

该语言功能首先在 ISO C99, 6.7.2.1 (16) 中标准化。 在后续修订版 ISO C11 中，第 6.7.2.1 (18) 节对其进行了规定。

您可以这样使用它们：

struct Header {
    size_t d;
    long v[];
};
typedef struct Header Header;
size_t n = 123; // can dynamically change during program execution
// ...
Header *h = malloc(sizeof(Header) + sizeof(long[n]));
h->n = n;

或者，您可以这样分配：

Header *h = malloc(sizeof *h + n * sizeof h->v[0]);

sizeof(Header) 包括最终的填充字节，因此，以下分配是不正确的，并且可能会产生缓冲区溢出：

Header *h = malloc(sizeof(size_t) + sizeof(long[n])); // invalid!

请注意， 灵活的数组成员将其分配数量减少了 1/2，即，您只需要 1 次分配，而不是为一个结构对象分配 2 次。这意味着内存分配器簿记开销所占用的内存更少。 此外，还可以节省一个额外指针的存储空间。 因此，如果您必须分配大量此类结构实例，则可以显着提高程序的运行时间和内存使用率（通过一个常数因子）。

与此相反，对灵活数组成员使用非标准化构造会产生未定义的行为（例如，long v[0]; 或 long v[1];）显然这是不好的做法。 因此，与任何未定义的行为一样，应该避免这种情况。

自 ISO C99 于 1999 年发布以来，距今已有 20 多年的历史，争取 ISO C89 兼容性已成为一个无力的论据。

Answer 3

请仔细阅读此答案下面的评论

随着 C 标准化的推进，没有理由再使用 [1]。

我不这样做的原因是它为了使用此功能而将代码绑定到 C99 是不值得的。

关键是您始终可以使用以下惯用语：

struct header {
  size_t len;
  unsigned char data[1];
};

那是完全可移植的。 然后，在为数组 data 中的 n 个元素分配内存时，您可以考虑 1：

ptr = malloc(sizeof(struct header) + (n-1));

如果您已经将 C99 作为出于任何其他原因构建代码的要求，或者您的目标是特定的编译器，我认为没有什么坏处。

Answer 4

你的意思是...

struct header
{
 size_t len;
 unsigned char data[];
}; 

在C 语言中，这是一个常见的习惯用法。 我认为许多编译器也接受：

  unsigned char data[0];

是的，它很危险，但话又说回来，它实际上并不比普通的 C 数组更危险 - 即，非常危险;-)。 请谨慎使用它，并且仅在您确实需要未知大小的数组的情况下使用它。 确保正确地分配和释放内存，使用如下方法：-

  foo = malloc(sizeof(header) + N * sizeof(data[0]));
  foo->len = N;

另一种方法是使数据只是指向元素的指针。 然后，您可以根据需要将数据 realloc() 到正确的大小。

  struct header
    {
     size_t len;
     unsigned char *data;
    }; 

当然，如果您询问的是 C++，那么这两种做法都不是好的做法。 那么您通常会使用 STL 向量。

Answer 5

我见过这样的事情：
来自C接口和实现。

  struct header {
    size_t len;
    unsigned char *data;
};

   struct header *p;
   p = malloc(sizeof(*p) + len + 1 );
   p->data = (unsigned char*) (p + 1 );  // memory after p is mine! 

注意：数据不必是最后一个成员。

Answer 6

作为旁注，为了 C89 兼容性，这样的结构应该像这样分配：

struct header *my_header
  = malloc(offsetof(struct header, data) + n * sizeof my_header->data);

或者使用宏：

#define FLEXIBLE_SIZE SIZE_MAX /* or whatever maximum length for an array */
#define SIZEOF_FLEXIBLE(type, member, length) \
  ( offsetof(type, member) + (length) * sizeof ((type *)0)->member[0] )

struct header {
  size_t len;
  unsigned char data[FLEXIBLE_SIZE];
};

...

size_t n = 123;
struct header *my_header = malloc(SIZEOF_FLEXIBLE(struct header, data, n));

将 FLEXIBLE_SIZE 设置为 SIZE_MAX 几乎确保这会失败：

struct header *my_header = malloc(sizeof *my_header);

Answer 7

有时，结构的使用方式存在一些缺点，如果您不仔细考虑其含义，可能会很危险。

对于您的示例，如果您启动一个函数：

void test(void) {
  struct header;
  char *p = &header.data[0];

  ...
}

那么结果是未定义的（因为没有为数据分配存储空间）。 这是您通常会意识到的事情，但在某些情况下，C 程序员可能习惯于能够使用结构的值语义，这会以各种其他方式分解。

例如，如果我定义：

struct header2 {
  int len;
  char data[MAXLEN]; /* MAXLEN some appropriately large number */
}

那么我可以简单地通过赋值来复制两个实例，即：

struct header2 inst1 = inst2;

或者如果它们被定义为指针：

struct header2 *inst1 = *inst2;

但是，这对于灵活的数组成员不起作用，因为它们的内容不会被复制。 您想要的是动态分配结构的大小并使用 memcpy 或等效方法复制数组。

struct header3 {
  int len;
  char data[]; /* flexible array member */
}

同样，编写接受 struct header3 的函数也行不通，因为函数调用中的参数再次按值复制，因此您得到的可能只是灵活数组的第一个元素成员。

 void not_good ( struct header3 ) ;

这并不是一个坏主意，但您必须记住始终动态分配这些结构并仅将它们作为指针传递。

 void good ( struct header3 * ) ;