c - “静态数组的动态数组”

Question

如何在 C 中指定静态数组的动态数组？
我想制作一个包含两个静态数组动态数组的结构。

struct indexed_face_set {
    double * [3] vertices;
    int * [3] faces;
};

这应该包含一个动态的顶点列表，每个顶点是 3 个双精度数，以及一个动态的面列表，每个顶点是 3 个整数。

Answer 1

语法是，C 的声明方法不是最干净的，C++ 继承了...

double (*vertices)[3];

该声明意味着这vertices是一个指向double [3]对象的指针。请注意，括号是必需的，否则（如double *vertices[3]）将意味着 3 的数组double*。

一段时间后，你最终习惯了表达式括号的倒置方式......

Answer 2

For the specific case of a structure containing two arrays each of dimension 3, it would be simpler to make the arrays a part of the structure, rather than dynamically allocating them separately:

struct indexed_face_set
{
    double vertices[3];
    int    faces[3];
};

However, there certainly could be cases where it makes sense to handle dynamic array allocation. In that case, you need a pointer to an array in the structure (and not an array of pointers). So, you would need to write:

struct indexed_face_set
{
    double (*vertices)[3];
    int    (*faces)[3];
};

To allocate a complete struct indexed_face_set, you need to use something like new_indexed_face_set() and to free one you need to use something like destroy_indexed_face_set():

struct indexed_face_set *new_indexed_face_set(void)
{
    struct indexed_face_set *new_ifs = malloc(sizeof(*new_ifs));
    if (new_ifs != 0)
    {
        double (*v)[3] = malloc(sizeof(*v));
        int    (*f)[3] = malloc(sizeof(*f));
        if (v == 0 || f == 0)
        {
            free(v);
            free(f);
            free(new_ifs);
            new_ifs = 0;
        }
        else
        {
            new_ifs->vertices = v;
            new_ifs->faces = f;
        }
    }
    return(new_ifs);
}

void destroy_indexed_face_set(struct indexed_face_set *ifs)
{
    if (ifs != 0)
    {
        free(ifs->vertices);
        free(ifs->faces);
        free(ifs);
    }
}

Then you can use it like this:

void play_with_ifs(void)
{
    struct indexed_face_set *ifs = new_indexed_face_set();
    if (ifs != 0)
    {
        (*ifs->vertices)[0] = 3.14159;
        (*ifs->vertices)[1] = 2.71813;
        (*ifs->vertices)[2] = 1.61803;
        (*ifs->faces)[0] = 31;
        (*ifs->faces)[1] = 30;
        (*ifs->faces)[2] = 29;
        do_something_fancy(ifs);
        destroy_indexed_face_set(ifs);
    }
}

Note that the notation using pointers to arrays is moderately messy; one reason why people do not often use them.

You could use this fragment as the body of a header:

#ifndef DASS_H_INCLUDED
#define DASS_H_INCLUDED

struct indexed_face_set;
extern void play_with_ifs(void);
extern void do_something_fancy(struct indexed_face_set *ifs);
extern void destroy_indexed_face_set(struct indexed_face_set *ifs);
extern struct indexed_face_set *new_indexed_face_set(void);

#endif /* DASS_H_INCLUDED */

It doesn't need any extra headers included; it does not need the details of the structure definition for these functions. You'd wrap it in suitable header guards.

---

Because the code above is a bit messy when it comes to using the arrays, most people would use a simpler notation. The header above can be left unchanged, but the code could be changed to:

struct indexed_face_set
{
    double *vertices;
    int    *faces;
};

struct indexed_face_set *new_indexed_face_set(void)
{
    struct indexed_face_set *new_ifs = malloc(sizeof(*new_ifs));
    if (new_ifs != 0)
    {
        double *v = malloc(3 * sizeof(*v));
        int    *f = malloc(3 * sizeof(*f));
        if (v == 0 || f == 0)
        {
            free(v);
            free(f);
            free(new_ifs);
            new_ifs = 0;
        }
        else
        {
            new_ifs->vertices = v;
            new_ifs->faces = f;
        }
    }
    return(new_ifs);
}

void destroy_indexed_face_set(struct indexed_face_set *ifs)
{
    if (ifs != 0)
    {
        free(ifs->vertices);
        free(ifs->faces);
        free(ifs);
    }
}

void play_with_ifs(void)
{
    struct indexed_face_set *ifs = new_indexed_face_set();
    if (ifs != 0)
    {
        ifs->vertices[0] = 3.14159;
        ifs->vertices[1] = 2.71813;
        ifs->vertices[2] = 1.61803;
        ifs->faces[0] = 31;
        ifs->faces[1] = 30;
        ifs->faces[2] = 29;
        do_something_fancy(ifs);
        destroy_indexed_face_set(ifs);
    }
}

This is much simpler to understand and use and would generally be regarded as more idiomatic C.

Since the size of each array is fixed, there's no particular need to record the size in the structure. If the sizes varied at runtime, and especially if some indexed face sets had, say, 8 vertices and 6 faces (cuboid?), then you might well want to record the sizes of the arrays in the structure. You'd also specify the number of vertices and number of faces in the call to new_indexed_face_set().