你有一个长度为 0 的数组作为 C90 和 C99 结构的最后一个成员的 struct hack 是众所周知的，并且随着 C99 中灵活数组成员的引入，我们甚至获得了一种使用它的标准化方式[]。不幸的是，C++ 没有提供这样的结构，并且(至少对于 Clang 3.4)，使用 [0] 或 [] 编译结构将使用 --std=c++11 -pedantic 产生编译警告:

$ cat test.cpp 
struct hack {
  char filler;
  int things[0];
};
$ clang++ --std=c++11 -pedantic test.cpp
\test.cpp:3:14: warning: zero size arrays are an extension [-Wzero-length-array]
  int things[0];

类似

$ cat test.cpp 
struct fam {
  char filler;
  int things[];
};
$ clang++ --std=c++11 -pedantic test.cpp
\test.cpp:3:7: warning: flexible array members are a C99 feature [-Wc99-extensions]
  int things[];

那么我的问题是这样的；假设我想要一个包含可变大小数组的结构作为 C++ 中的最后一项。考虑到同时支持两者的编译器，正确的做法是什么？我应该使用 struct hack [0] (这是一个编译器扩展)还是 FAM [] (这是一个 C99 功能)？据我了解，两者都可以，但我想弄清楚哪个是较小的邪恶？

此外，在人们开始建议将 int* 保留到结构中单独分配的一 block 内存之前，这不是一个令人满意的答案。我想分配一 block 内存来保存我的结构和数组元素。使用 std::vector 也属于同一类别。如果你想知道为什么我不想使用指针，R.'s answer对另一个问题给出了很好的概述。

其他地方也有类似的问题，但没有人回答这个特定的问题:

• Are flexible array members valid in C++? :非常相似，但问题是 FAM 在 C++ 中是否有效(否)。我正在寻找一个选择其中一个的充分理由。
• Conforming variant of the old “struct hack” : 提出了一个替代方案，但它既不漂亮，也不总是正确的(如果将填充添加到结构中会怎样？)。稍后访问元素也不像 e.things[42] 那样干净。

最佳答案

您可以使用成员(member)获得或多或少相同的效果 函数和 reinterpret_cast :

int* buffer() { return reinterpret_cast<int*>(this + 1); }

这有一个主要缺陷:它不能保证正确 结盟。例如，类似:

struct Hack
{
    char size;
    int* buffer() { return reinterpret_cast<int*>(this + 1); }
};

可能会返回未对齐的指针。你可以解决 这是通过将结构中的数据与类型放在一个 union 中 你要返回谁的指针。如果你有 C++11，你可以 声明:

struct alignas(alignof(int)) Hack
{
    char size;
    int* buffer() { return reinterpret_cast<int*>(this + 1); }
};

(我想。我从来没有真正尝试过这个，我可以有一些 语法错误的细节。)

这个成语有第二个重要缺陷:它对 确保大小字段对应于实际大小 缓冲区，更糟糕的是，没有真正的方法使用 new这里。至 纠正这个，有点，你可以定义一个特定的类 operator new和 operator delete :

struct alignas(alignof(int)) Hack
{
    void* operator new( size_t, size_t n );
    void operator delete( void* );
    Hack( size_t n );
    char size;
    int* buffer() { return reinterpret_cast<int*>(this + 1); }
};

然后客户端代码将不得不使用placement new 来分配:

Hack* hack = new (20) Hack(20);

客户仍然需要重复尺寸，但他不能忽视 它。

还有一些技术可以用来防止创建 未动态分配的实例等最终结束 类似于:

struct alignas(alignof(int)) Hack
{
private:
    void operator delete( void* p )
    {
        ::operator delete( p );
    }
    //  ban all but dynamic lifetime (and also inheritance, member, etc.)
    ~Hack() = default;

    //  ban arrays
    void* operator new[]( size_t ) = delete;
    void operator delete[]( void* p ) = delete;
public:
    Hack( size_t n );
    void* operator new( size_t, size_t n )
    {
        return ::operator new( sizeof(Hack) + n * sizeof(int) );
    }
    char size;
    //  Since dtor is private, we need this.
    void deleteMe() { delete this; }
    int* buffer() { return reinterpret_cast<int*>(this + 1); }
};

鉴于此类类(class)的基本危险，这是值得商榷的 如果需要这么多的保护措施。即使和他们在一起， 它真的只有完全了解所有内容的人才能使用 制约因素，正在认真关注。总之，除了 极端情况下，在非常低级的代码中，你只需要做 缓冲 a std::vector<int>并完成它。除了 最低级别的代码，性能差异不会 值得冒险和努力。

编辑:

举个例子，g++ 的实现 std::basic_string使用与上述非常相似的东西， 与 struct包含引用计数，当前大小 和当前容量(三个 size_t )，然后直接 字符缓冲区。而且因为它是很久以前写的 C++11 和 alignas/alignof ， 就像是 std::basic_string<double>会在某些系统上崩溃(例如 一个Sparc)。 (虽然从技术上讲是一个错误，但大多数人不考虑 这是一个关键问题。)

关于c++ - C++ 中的 Struct hack 等价物，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/20290293/