Comstackción de errores en C al crear una matriz dinámica dentro de la estructura de datos

Así que tengo un progtwig en el que estoy trabajando para implementar un B-Tree, pero estoy recibiendo algunos errores de comstackción molestos. La estructura del árbol B estaba funcionando, pero tengo que implementar una funcionalidad para aceptar el orden del árbol como una entrada, lo que está causando algunos problemas. Los errores que tengo son:

Prelim.c: 29: 38: error: esperado ‘:’, ‘,’, ‘;’, ‘}’ o ‘ atributo ‘ antes ‘=’ token

Prelim.c: 26: 6: error: miembro de matriz flexible que no se encuentra al final de la estructura

El código afectado es:

struct bTreeNode { int count; int value[]; // This is line 26 struct bTreeNode *branch[]; struct bTreeNode *branch[order - 1] = malloc(sizeof(order)); // This is line 29 int value[order - 1] = malloc(sizeof(order)); }; 

Mi pregunta tiene dos partes: primero, ¿por qué ocurren estos errores y, segundo, cómo puedo implementar esta idea correctamente? (Puedo proporcionar código adicional si es necesario y el orden se declara como una variable global). ¡Muchas gracias por su ayuda!

  1. “por qué están ocurriendo estos errores”

    En su código, la branch es una matriz de punteros bTreeNode , por lo que debe indicar al comstackdor la longitud de la branch . prueba este código:

     #define ORDER 10; // hard-coded struct bTreeNode { int count; int value[ORDER]; struct bTreeNode *branch[ORDER - 1]; int value[ORDER - 1]; }; 

    Y no puede utilizar ninguna función en la definición de struct bTreeNode .

  2. “¿Cómo puedo implementar esta idea correctamente?”

    La matriz flexible es una buena idea, intente con struct bTreeNode *branch[0] , y asigne memoria más tarde. Lo siento por mi feo inglés. ^ _ ^

esta statement tiene un problema

 struct bTreeNode *branch[order - 1] = malloc(sizeof(order)); 

se supone que el puntero de twig apunta a (orden – 1) nodos b-tree, pero está asignando el tamaño de orden de la memoria (que probablemente sea un int, por lo que probablemente retornará 4 bytes) necesita asignar la memoria de btreeNode veces el orden (número de nodos btree * orden). prueba esto..

 struct bTreeNode *branch = malloc(sizeof(struct bTreeNode)*order); 

Está teniendo un miembro de matriz flexible , que está dentro de una struct una matriz sin dimensiones conocidas en el momento de la comstackción. Solo puedes tener uno de ellos, y debe ser el último miembro de la struct :

 struct bTreeNode { int count; int value[]; // flexible array member }; 

miembros de matriz flexible es una característica avanzada de C99

Supongo que quieres que tu nodo tenga un número arbitrario de valores y un número arbitrario de hijos. Necesitas dos struct flexibles para eso y debes usar punteros.

 // forward declarations struct bTreeNode; struct bTreeNumber; struct bTreeSons; struct bTreeNumber { unsigned valcount; int value[]; // actual dimension is valcount }; struct bTreeSons { unsigned soncount; struct bTreeNode* ptrs[]; // actual dimension is soncount }; struct bTreeNode { struct bTreeNumbers* numbers; struct bTreeSons* sons; }; 

Aquí hay una función que asigna un nodo vacío con un número dado de valores y otro número de hijos

 struct bTreeNode *make_node (unsigned nbval, unsigned nbsons) { struct bTreeNumber* pnum = malloc(sizeof(bTreeNumber)+nbval*sizeof(int)); if (!pnum) { perror("malloc bTreeNumber"); exit(EXIT_FAILURE); }; pnum->valcount = nbval; if (nbval>0) memset (pnum->value, 0, nbval*sizeof(int)); struct bTreeSon* pson = malloc(sizeof(bTreeSon)+nbsons*sizeof(struct bTreeNode*)); if (!pson) { perror("malloc bTreeSon"); exit(EXIT_FAILURE); }; pson->soncount = nbsons; for (unsigned ix=0; ixptrs[i] = NULL; struct bTreNode *pnode = malloc(sizeof(struct bTreeNode)); if (!pnode) {perror("malloc bTreeNode"); exit(EXIT_FAILURE)); pnode->numbers = pnum; pnode->sons = pson; return pnode; } 

Alternativamente, puede decidir que sus nodos tengan un puntero a los números y un miembro de matriz flexible para los hijos (o viceversa)

  // alternatively struct bTreeNode { unsigned nbsons; struct bTreeNumber* numbers; struct bTreeNode* sons[]; // actual dimension is nbsons }; 

o incluso más “de la vieja escuela” puede hacer que el nodo conozca el número de hijos y el número de valores, y mantenga los punteros a los arreglos (asignados en montón) de ellos:

  // without flexible members struct bTreeNode { unsigned nbsons; unsigned nbvalues; int* pvalues; // point to an array of dimension nbvalues struct bTreeNode** psons; // point to an array of dimension nbsons };