灵活数组成员在 C++ 中有效吗？

Question

在 C99 中，您可以像这样声明结构的灵活数组成员：

struct blah
{
    int foo[];
};

但是，当有人在工作中尝试使用 C++ 中的 clang 编译一些代码时，该语法不起作用。 （它一直在与 MSVC 一起使用。）我们必须将其转换为：

struct blah
{
    int foo[0];
};

纵观 C++ 标准，我发现根本没有对灵活成员数组的引用；我一直认为 [0] 是一个无效的声明，但显然对于灵活的成员数组来说它是有效的。灵活成员数组在 C++ 中实际上有效吗？如果是这样，正确的声明是 [] 还是 [0]？

Answer 1

C++ 于 1998 年首次标准化，因此它早于向 C 添加灵活数组成员（这是 C99 中的新增功能）。 2003 年对 C++ 进行了勘误，但没有添加任何相关的新功能。 C++ (C++2b) 的下一个修订版仍在开发中，并且似乎仍然没有添加灵活的数组成员。

Answer 2

C++ 不支持结构末尾的 C99 灵活数组成员，无论是使用空索引表示法还是 0 索引表示法（禁止供应商特定的扩展）：

struct blah
{
    int count;
    int foo[];  // not valid C++
};

struct blah
{
    int count;
    int foo[0]; // also not valid C++
};

据我所知，C++ 0x 也不会添加这个。

但是，如果将数组大小设置为 1 个元素：

struct blah
{
    int count;
    int foo[1];
};

代码将编译并运行得很好，但从技术上讲，这是未定义的行为。您可以使用不太可能出现相差一错误的表达式来分配适当的内存：

struct blah* p = (struct blah*) malloc( offsetof(struct blah, foo[desired_number_of_elements]);
if (p) {
    p->count = desired_number_of_elements;

    // initialize your p->foo[] array however appropriate - it has `count`
    // elements (indexable from 0 to count-1)
}

因此它可以在 C90、C99 和 C++ 之间移植，并且与 C99 灵活的数组成员一样工作。

Raymond Chen 对此做了一篇很好的文章： 为什么某些结构以数组结尾size 1？

注意：在 Raymond Chen 的文章中，初始化“灵活”数组的示例中存在拼写错误/错误。它应该是：

for (DWORD Index = 0; Index < NumberOfGroups; Index++) { // note: used '<' , not '='
  TokenGroups->Groups[Index] = ...;
}

Answer 3

如果您可以将应用程序限制为仅需要几个已知大小，那么您可以使用模板有效地实现灵活的数组。

template <typename BASE, typename T, unsigned SZ>
struct Flex : public BASE {
    T flex_[SZ];
};

Answer 4

第二个不会包含元素，而是指向 blah 之后。因此，如果您有这样的结构：

struct something
{
  int a, b;
  int c[0];
};

您可以执行以下操作：

struct something *val = (struct something *)malloc(sizeof(struct something) + 5 * sizeof(int));
val->a = 1;
val->b = 2;
val->c[0] = 3;

在这种情况下，c 将表现为具有 5 个 int 的数组，但数组中的数据将在 something 结构之后。

我正在开发的产品使用它作为大小字符串：

struct String
{
  unsigned int allocated;
  unsigned int size;
  char data[0];
};

由于受支持的架构，这将消耗 8 个字节加上分配的。

当然，所有这些都是 C 语言，但是 g++ 可以顺利地接受它。

Answer 5

一项提案正在进行中，可能会成为未来的 C++ 版本。
请参阅http://www.open-std .org/jtc1/sc22/wg21/docs/papers/2018/p1039r0.html 了解详细信息（该提案相当新，因此可能会发生变化）

Answer 6

如果您只需要

struct blah { int foo[]; };

，那么您根本不需要该结构，您可以简单地处理 malloc'ed/new'ed int 数组。

如果您在开头有一些成员：

struct blah { char a,b; /*int foo[]; //not valid in C++*/ };

那么在 C++ 中，我想您可以将 foo 替换为 foo 成员函数：

struct blah { alignas(int) char a; char b; 
    int *foo(void) { return reinterpret_cast<int*>(&this[1]); } };

使用示例：

#include <stdlib.h>
struct blah { 
    alignas(int) char a;
    char b;
    ////////
    int *foo(void) { return reinterpret_cast<int*>(&this[1]); }
};
int main()
{
    blah *b = (blah*)malloc(sizeof(blah)+10*sizeof(int));
    if(!b) return 1;
    b->foo()[1]=1;
}

此类型不存在严格的别名问题此处将内存转换为初始结构，因为内存是动态的（没有声明的类型）。

Answer 7

灵活数组尚未成为 C++ 标准的一部分。这就是 int foo[] 或 int foo[0] 可能无法编译的原因。虽然有一个提案讨论过，但尚未被最新版本的 C++ (C++2b) 接受。

然而，几乎所有现代编译器都通过编译器扩展来支持它。

• GCC 有零长度数组扩展< /a> C++ 支持。
• Clang 旨在支持广泛的 GCC扩展。
• MSVC 有一个非标准扩展和一个 与其关联的警告。

问题是，如果您使用最高警告级别的扩展 (-Wall --pedantic)，可能会导致警告。

解决此问题的一种方法是使用包含一个元素的数组并进行越界访问。虽然此解决方案符合规范（dcl.array 和 < a href="https://timsong-cpp.github.io/cppwp/expr.add#4" rel="nofollow noreferrer">expr.add)，大多数编译器都会生成有效的代码，甚至clang -fsanitize=undefined 对此感到满意：

#include <new>
#include <type_traits>

struct A {
    int a[1];
};

int main()
{
    using storage_type = std::aligned_storage_t<1024, alignof(A)>;
    static storage_type memory;
    
    A *ptr_a = new (&memory) A;

    ptr_a->a[2] = 42;
    
    return ptr_a->a[2];
}

演示< /a>

---

Having all that said, if you want your code to be standard compliant and do not depend on any compiler extension, you will have to avoid using this feature.

Answer 8

我在声明可从 C++ 代码中使用的灵活数组成员时遇到了同样的问题。通过查看 glibc 头文件，我发现灵活数组成员有一些用法，例如在 struct inotify 中声明如下（省略注释和一些不相关的成员）

struct inotify_event
{
  //Some members
  char name __flexarr;
};

： __flexarr 宏又被定义为

/* Support for flexible arrays.
   Headers that should use flexible arrays only if they're "real"
   (e.g. only if they won't affect sizeof()) should test
   #if __glibc_c99_flexarr_available.  */
#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
# define __flexarr  []
# define __glibc_c99_flexarr_available 1
#elif __GNUC_PREREQ (2,97)
/* GCC 2.97 supports C99 flexible array members as an extension,
   even when in C89 mode or compiling C++ (any version).  */
# define __flexarr  []
# define __glibc_c99_flexarr_available 1
#elif defined __GNUC__
/* Pre-2.97 GCC did not support C99 flexible arrays but did have
   an equivalent extension with slightly different notation.  */
# define __flexarr  [0]
# define __glibc_c99_flexarr_available 1
#else
/* Some other non-C99 compiler.  Approximate with [1].  */
# define __flexarr  [1]
# define __glibc_c99_flexarr_available 0
#endif

我不熟悉 MSVC 编译器，但可能您必须根据 MSVC< 添加一个条件宏/代码> 版本。

Answer 9

然而，clang 文档说，标准 C++ 不支持灵活的数组成员。

“除了此处列出的语言扩展之外，Clang 还旨在支持广泛的 GCC 扩展。”

C++ 的 gcc 文档说。

“GNU 编译器为 C++ 语言提供了这些扩展（并且您还可以在 C++ 程序中使用大多数 C 语言扩展）。”

C 文档的 gcc 文档支持零长度数组。

https://gcc.gnu.org/onlinedocs/gcc/Zero-Length。 html

Answer 10

更好的解决方案是将其声明为指针：

struct blah
{
    int* foo;
};

或者更好的是，将其声明为 std::vector ：

struct blah
{
    std::vector<int> foo;
};