动态声明的结构数组

Question

假设我们要构造一个结构数组，在编译时无法知道该结构的定义。

这是一个SSCCE ：

#include <stdlib.h>

int main(int argc, char *argv[]){
    if (argc < 3) return 1;
    int n = atoi(argv[1]);
    int k = atoi(argv[2]);
    if ((n < 1) || (k < 1)) return 2;

    // define struct dynamically
    typedef struct{
        int a[n];
        short b[k];
    }data_point_t;

    int m = 10;
    // construct array of `m` elements
    data_point_t *p = malloc(sizeof(data_point_t)*m);

    // do something with the array
    for(int i = 0; i < m; ++i) p[i].a[0] = p[i].b[0] = i; 
    free(p);
    return 0;
}

这在gcc （ C99 ）上可以正常工作，但是在clang却不能，结果如下：

error: fields must have a constant size: 
       'variable length array in structure' extension will never be supported

因此，我显然依赖于gcc扩展。 我的问题是，如何在符合标准C99处理此类问题？ （奖金问题：如何在C++11做到这一点？）

注意：性能很重要，迭代p时应该对齐内存访问。 在循环中取消引用指针会产生随机的内存访问，这不是一种选择。

Answer 1

我认为您最好的选择是放弃将数组包装在结构中的想法，硬着头皮自己分配2D数组。

这将意味着您需要进行显式索引编制，但是无论如何都必须在后台进行。

对齐时，如果要访问m n数组中的每个数组中的每个n数组元素，可能都没关系，最好使它们紧凑以最大程度地使用缓存。

就像是：

int *array = malloc(m * n * sizeof *array);

然后索引，只需执行以下操作：

// do something with the array
for(int i = 0; i < m; ++i)
{
  for(int j = 0; j < n; ++j)
    array[i * n + j] = j;
}

如果您非常担心这种乘法，请使用临时指针。 分析后，当然。

有时，您可以使用辅助宏完成此工作以建立索引：

#define INDEX(a, n, i, j)  (a)[(i) * (n) + (j)]

那么您可以将最后一行写为：

INDEX(array, n, i, j) = j;

当然，这有点笨拙，因为n需要一直都在那儿走。

Answer 2

首先，只有在存在其他结构成员的情况下，将数组包装在结构中才有意义。 如果没有其他结构成员，只需分配一个数组。

如果还有其他struct成员，请使用一个灵活的数组成员来实现您想要的。 灵活的数组成员在C标准中定义明确，可在每个C99编译器上使用。

// define struct dynamically
typedef struct{

    type_t the_reason_you_need_this_to_be_a_struct_and_not_an_array;
    int a[]; // flexible array member
}data_point_t;

// construct array of `m` elements
int m = 10;
size_t obj_size = sizeof(data_point_t) + n*sizeof(int);
data_point_t *p = malloc(m * obj_size);

Answer 3

在C ++中，您当然可以像现在一样使用指针，但是对于“适当的” C ++解决方案，唯一可行的解​​决方案是使用std::vector ：

struct data_point_t
{
    explicit data_point_t(const size_t sz)
        : a(sz)  // Construct the vector `a` with `sz` entries,
                 // each element will be zero initialized (`int()`)
    {}

    std::vector<int> a;
};

int main(int argc, char *argv[]){
    // Read `n`...
    int n = 10;  // Just example

    // Read `m`...
    int m = 10;  // Just example

    // Construct vector of `m` elements
    std::vector<data_point_t> p(m, data_point_t(n));

    // Here the vector `p` contains `m` elements, where each instance
    // have been initialized with a vector `a` with `n` elements
    // All fully allocated and initialized

    // Do something with the array
    // ...
}

这是有效的C ++ 03代码，因此，除非您使用古老的语言（例如Turbo C ++），否则当今任何编译器都应支持它。