Как создать структуру структур известного максимального размера

Чтобы создать переменную типа 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
}

Почему? Потому что вы не хотите переделывать весь свой код после того, как передумаете (или переключитесь на другое устройство) и решите разместить матрицы в куче. Вы просто изменяете свои функции init и destroy.

Я думаю, вам следует подойти к этому более детально и начать с выделения места для каждого arm_matrix_instance_f32 отдельно. Рассмотрите возможность создания фабричной функции для этих экземпляров. Это создаст более читаемый код и позволит вам просто заменить arm_matrix_instance_f32 в вашем dataset другими экземплярами.

С другой стороны, если вы всегда знаете количество матриц и максимальное количество элементов, которые они содержат, вы можете использовать составные литералы для создания набора данных:

 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,
             }
         },

     };
 }

Это освободит вас от выделения/освобождения кучи.

Осторожно, указатели и массивы — разные животные!

Здесь 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
}