Problema al implementar una matriz dinámica de estructuras

Tengo un problema al crear una matriz dinámica de estructuras. He visto e intentado implementar algunos ejemplos aquí y en otros sitios, los ejemplos y la forma en que asignan la memoria tienden a diferir, y parece que ninguno de ellos funciona para mí. Cualquier ayuda sería muy apreciada.

typedef struct node { int index; int xmin, xmax, ymin, ymax; } partition; partition* part1 = (partition *)malloc(sizeof(partition) * 50); 

Ni siquiera puedo hacer esto bien. Me da el siguiente error: error: el elemento inicializador no es constante

Si alguien pudiera explicar cómo debería implementarse algo como esto, lo apreciaría enormemente.

Además, una vez que tenga esa parte hacia abajo, ¿cómo agregaría valores a los elementos de la estructura? ¿Funcionaría algo como el de abajo?

 part1[i]->index = x; 

El comstackdor se queja porque estás haciendo:

 partition* part1 = (partition *)malloc(sizeof(partition) * 50); 

Haga esto en su lugar:

 partition* part1; int main(void) { part1 = (partition *)malloc(sizeof(partition) * 50); ... } 

Su versión utilizó un inicializador en un global, que en C debe ser un valor constante. Al mover el malloc a una función, está “inicializando el valor” con su código, pero no está utilizando un inicializador como se define en el idioma.

Igualmente, pudiste haber tenido un global que se inicializó:

 int twenty_two = 22; 

Aquí 22 es una constante y por lo tanto permisible.

ACTUALIZACIÓN: Este es un ejemplo un tanto largo que mostrará la mayoría de las formas posibles:

 #define PARTMAX 50 partition static_partlist[PARTMAX]; partition *dynamic_partlist; int grown_partmax; partition *grown_partlist; void iterate_byindex_static_length(partition *partlist) { int idx; for (idx = 0; idx < PARTMAX; ++idx) do_something(&partlist[idx]); } void iterate_byptr_static_length(partition *partlist) { partition *cur; partition *end; // these are all equivalent: // end = partlist + PARTMAX; // end = &partlist[PARTMAX]; end = partlist + PARTMAX; for (cur = partlist; cur < end; ++cur) do_something(cur); } void iterate_byindex_dynamic_length(partition *partlist,int partmax) { int idx; for (idx = 0; idx < partmax; ++idx) do_something(&partlist[idx]); } void iterate_byptr_dynamic_length(partition *partlist,int partmax) { partition *cur; partition *end; // these are all equivalent: // end = partlist + partmax; // end = &partlist[partmax]; end = partlist + partmax; for (cur = partlist; cur < end; ++cur) do_something(cur); } int main(void) { partition *part; dynamic_partlist = malloc(sizeof(partition) * PARTMAX); // these are all the same iterate_byindex_static_length(dynamic_partlist); iterate_byindex_static_length(dynamic_partlist + 0); iterate_byindex_static_length(&dynamic_partlist[0]); // as are these iterate_byptr_static_length(static_partlist); iterate_byptr_static_length(static_partlist + 0); iterate_byptr_static_length(&static_partlist[0]); // still the same ... iterate_byindex_dynamic_length(dynamic_partlist,PARTMAX); iterate_byindex_dynamic_length(dynamic_partlist + 0,PARTMAX); iterate_byindex_dynamic_length(&dynamic_partlist[0],PARTMAX); // yet again the same ... iterate_byptr_dynamic_length(static_partlist,PARTMAX); iterate_byptr_dynamic_length(static_partlist + 0,PARTMAX); iterate_byptr_dynamic_length(&static_partlist[0],PARTMAX); // let's grow an array dynamically and fill it ... for (idx = 0; idx < 10; ++idx) { // grow the list -- Note that realloc is smart enough to handle // the fact that grown_partlist is NULL on the first time through ++grown_partmax; grown_partlist = realloc(grown_partlist, grown_partmax * sizeof(partition)); part = &grown_partlist[grown_partmax - 1]; // fill in part with whatever data ... } // once again, still the same iterate_byindex_dynamic_length(grown_partlist,grown_partmax); iterate_byindex_dynamic_length(grown_partlist + 0,grown_partmax); iterate_byindex_dynamic_length(&grown_partlist[0],grown_partmax); // sheesh, do things ever change? :-) iterate_byptr_dynamic_length(grown_partlist,grown_partmax); iterate_byptr_dynamic_length(grown_partlist + 0,grown_partmax); iterate_byptr_dynamic_length(&grown_partlist[0],grown_partmax); } 

Hay dos formas básicas de interactuar a través de una matriz: by index y by pointer . No importa cómo se definió la matriz (por ejemplo, global/static -> int myary[37]; o vía malloc/realloc -> int *myptr = malloc(sizeof(int) * 37); ). La syntax "por índice" y las syntax "por puntero" son intercambiables. Si querías el elemento 12, todos los siguientes son equivalentes:

 myary[12] *(myary + 12) *(&myary[12]) myptr[12] *(myptr + 12) *(&myptr[12]) 

Es por eso que todo lo anterior producirá los mismos resultados.