如何创建已知最大大小的结构结构

Question

编辑：我现在意识到我在数组和指针之间造成的混淆。我很欣赏这些评论，但不会使问题更准确，因为它会失去我写它的部分原因。

我正在尝试初始化一个由结构组成的结构，每个结构都包含一个数组。更清楚地说，我有这个矩阵结构：

typedef struct
{
    uint16_t numRows;     /**< number of rows of the matrix.     */
    uint16_t numCols;     /**< number of columns of the matrix.  */
    float32_t *pData;     /**< points to the data of the matrix. */
} arm_matrix_instance_f32;

我需要将这些矩阵对象中的一些组合成一个更大的结构

typedef struct
{
    arm_matrix_instance_f32 A;
    arm_matrix_instance_f32 B;
    arm_matrix_instance_f32 C;
} dataset;

作为参考，这个矩阵定义和后面用到的初始化函数，来自CMSIS中的arm_math库。

我很难理解应该如何创建 dataset 变量。在这个 question page 中的回答和讨论之后，我明白我不能神奇地期望 C 知道用 dataset d 这样的声明分配多少内存。

仅根据链接问题的解决方案，我想出了一个函数来为 dataset 初始化足够 space，并创建一个类型为 [=14= 的变量的函数].我现在有这样的东西：

dataset* create_dataset( void ) {

    uint8_t n_matrices = 3;
    uint8_t n_elements = 9;
    dataset* d= malloc( n_matrices * (sizeof(float32_t)*n_elements + sizeof(uint16_t)*2));
    memset(d, 0, sizeof(*d));

    const float32_t zeros33_f32[9] =
    {
        0.0, 0.0, 0.0,
        0.0, 0.0, 0.0,
        0.0, 0.0, 0.0,
    };
    const float32_t zeros31_f32[3] =
    {
        0.0,
        0.0,
        0.0,
    };
    const float32_t zeros13_f32[3] =
    {
        0.0, 0.0, 0.0,
    };

    arm_mat_init_f32( &(d->A), 3, 3, (float32_t *)zeros33_f32);
    arm_mat_init_f32( &(d->B), 3, 1, (float32_t *)zeros31_f32);
    arm_mat_init_f32( &(d->C), 1, 3, (float32_t *)zeros13_f32);

    return d;
}

基本上我是从假设矩阵的个数和它们包含的最大元素个数都是已知的出发，从而预留足够的内存。

我有以下问题：

这种嵌套结构的整体方法是否正确？
space 对 dataset 结构的分配是否正确？
我是否真的确保我创建的 dataset 结构中包含的所有 arm_matrix_instance_f32 元素都具有足够的 space 用于所有元素？
我声明该结构包含 A, B, C。如果我以另一个顺序初始化它们会怎样？例如，如果 B 仍未声明，结构如何知道 A 和 C 之间还有多少 space？

Answer 1

注意，指针和数组是不同的动物！

这里，arm_matrix_instance_f32 不包含数组，而是一个指针。 dataset 包含其中的 3 个。句号。

这意味着这行是完全错误的：

dataset* d= malloc( n_matrices * (sizeof(float32_t)*n_elements + sizeof(uint16_t)*2));

您应该改为单独分配结构和数组：

dataset* create_dataset( void ) {

    dataset* d = malloc(sizeof(*d));                  // allocate memory for the structs
    if (d == NULL) return NULL;                       // could not allocate
    // allocate memory for the arrays (9 + 3 + 3)
    float32_t *array = malloc(15 +  * sizeof(*array));
    if (array == NULL) {
        free(d);                                      // free d if array not allocated
        return NULL;
    }

    for (int i=0; i<15; i++) array[i] = 0.;           // zeroes the arrays

    arm_mat_init_f32( &(d->A), 3, 3, array);          // pass 9 first elements to A
    arm_mat_init_f32( &(d->B), 3, 1, array + 9);      // pass following 3 to B
    arm_mat_init_f32( &(d->C), 1, 3, array + 12);     // pass last 3 to C

    return d;
}

因为您已经用 malloc 分配了所有内容，所以您稍后必须释放它：

void destroy_dataset(dataset *d) {
    free(d->A.pData);      // free the array (A got the beginning of the allocated array)
    free(d);               // and the struct
}

Answer 2

我认为您应该对此采取更精细的方法，并从为每个 arm_matrix_instance_f32 分别分配 space 开始。考虑为这些实例创建一个工厂函数。它将生成更易读的代码，并允许您简单地将 dataset 中的 arm_matrix_instance_f32 替换为其他实例。

另一方面，如果您总是知道矩阵的数量和它们包含的元素的最大数量，您可以使用复合文字来生成数据集：

 dataset create()
 {
     return (dataset) {
         .A = {
             3, 3, (float32_t [])  {
                 1.0, 2.0, 3.0,
                 4.0, 5.0, 6.0,
                 7.0, 8.0, 9.0,
             }
         },
         .B = {
             3, 3, (float32_t [])  {
                 2.0, 0.0, 0.0,
                 0.0, 0.0, 0.0,
                 0.0, 0.0, 0.0,
             }
         },
         .C = {
             3, 3, (float32_t [])  {
                 2.0, 0.0, 0.0,
                 0.0, 0.0, 0.0,
                 0.0, 0.0, 0.0,
             }
         },

     };
 }

这将使您从堆中解放出来 allocation/deallocation。

Answer 3

要创建 dataset 类型的变量（或任何 struct 类型的变量）：

dataset d;

就是这样。仅此而已。

要在堆上分配类型为 dataset（或任何 struct 的对象）：

dataset* dp = malloc(sizeof(dataset));

就是这样。仅此而已。

现在正确初始化这样的对象是另一回事。但是为了初始化一些东西，你需要先创建那个东西。最好将创建和初始化这两个过程在思想上分开。

所以你手上有一个未初始化的struct。如何初始化它？逐个字段。

每个字段都是一个矩阵，可能需要自己进行复杂的初始化，所以最好写一个专门的矩阵初始化函数。先用一个吧，以后再写。假设您必须在堆上分配数据集。

dataset* allocate_dataset() {
       dataset* dp = malloc(sizeof(dataset));
       if (dp == NULL) { /* report out-of-memory error */ }
       init_matrix(&dp->A, 3, 3);
       init_matrix(&dp->B, 3, 1);
       init_matrix(&dp->C, 1, 3);
       return dp;
}

无论在堆上分配什么，最终都必须释放，所以我们写一个对称的释放函数：

void free_dataset(dataset* dp) {
       destroy_matrix(&dp->A);
       destroy_matrix(&dp->B);
       destroy_matrix(&dp->C);
       free(dp);
}

开始矩阵初始化。有一个库函数可以执行此操作，但它需要一个指向其数据数组的指针，该指针应分配在某处。我假设它存在于堆中。

void init_matrix(arm_mat_init_f32* mp, int rows, int cols) {
    float32_t* data = malloc(sizeof(float32_t * rows * cols);
    if (data == NULL) { /* report out-of-memory error */ }
    arm_mat_init_f32(mp, rows, cols, data);   
}

破坏矩阵几乎是微不足道的：

void destroy_matrix(arm_mat_init_f32* mp) {
    free (mp->pData);
}

同样，这假定您需要在堆上分配矩阵数据。不一定如此。也许您使用的是内存有限的嵌入式设备。现在让我们假设相反的情况：没有堆。你不需要分配你的数据集，但你仍然需要初始化它：

void init_dataset (dataset* dp);

而现在 init_matrix 除了调用 arm_mat_init_f32 什么都不做，所以我们可以直接使用后者：

void init_dataset (dataset* dp) {
    arm_mat_init_f32(&dp->A, 3, 3, (float32_t[]){0,0,0, 0,0,0, 0,0,0});
    arm_mat_init_f32(&dp->B, 3, 1, (float32_t[]){0,0,0});
    arm_mat_init_f32(&dp->C, 1, 3, (float32_t[]){0,0,0});
}

不需要销毁，但您可能仍希望保留不执行任何操作的销毁函数，以防万一，并在适当的时候调用它们。

void destroy_dataset(dataset* dp) { 
    destroy_matrix(&dp->A);
    destroy_matrix(&dp->B);
    destroy_matrix(&dp->C);
}

void destroy_matrix(arm_mat_init_f32* mp) { 
  (void)mp; // suppress compiler warning
}

为什么？因为一旦您改变主意（或切换到不同的设备）并决定在堆上分配矩阵，您不想重做 all 代码。您只需修改 init 和 destroy 函数。

如何创建已知最大大小的结构结构

How to create a struct of structs of known maximum size

c

struct

arm

memory-management

cmsis