Agregando un * extra dentro de var variables[26]; , puedo evitar la mezcla . y -> y use el mismo operador -> en todos los códigos. Mi compañero de clase sugirió que podría estar desperdiciando memoria extra, pero mejoró mi experiencia de codificación ya que cometí menos errores.
¿Se considera esto una mala práctica o aceptable?.
Versión original
#include <stdio.h> struct var { int ** num; int y; int x; int count; }; typedef struct var var; struct prog { var variables[26]; <===================================BEFORE CHANGE }; typedef struct prog prog; int main() { prog *p = calloc(1,sizeof(prog)); //p->variables[0] = calloc(1, sizeof(var)); p->variables[0].y=1; <========================= BEFORE CHANGE, USING '.' to access y return 0; }Versión modificada
#include <stdio.h> struct var { int ** num; int y; int x; int count; }; typedef struct var var; struct prog { var* variables[26]; <===================================Added * after var }; typedef struct prog prog; int main() { prog *p = calloc(1,sizeof(prog)); //p->variables[0] = calloc(1, sizeof(var)); p->variables[0]->y=1; <=========================== Now can use '->' instead of '.' return 0; }prog->variables en su segundo código es una matriz de var* . No puede simplemente escribir prog->variables[0]->y ya que variables[0] no se han asignado, debe llamar a malloc o calloc en cada elemento dentro de la matriz.
En primer lugar, ha cometido algunos errores en la conversión. Pero ese no es el tema principal.
Ciertamente, hay situaciones en las que se prefiere un puntero con asignación dinámica en lugar de una matriz. Pero no diría que hacer el cambio solo para poder escribir -> en lugar de . es una buena razón. Como programador de C, se espera que pueda hacer frente a ambos.
¿Se considera esto una mala práctica o es aceptable?
NUNCA aceptaría si alguien refactorizara el código para este propósito en particular.
var* variables[26]; asigna memoria para 26 objetos de puntero a var . No asigna ninguna memoria para los propios objetos var . Tal como está, su segundo programa de ejemplo tiene un comportamiento indefinido al intentar quitar la referencia a un puntero nulo.
Necesita la línea comentada (y posiblemente 25 más como esta)
p->variables[0] = calloc(1, sizeof(var));ya que esto es lo que asigna memoria para la estructura misma.
El uso de cambios de memoria automáticos frente a dinámicos para cada caso de uso. A menos que la memoria de pila sea una preocupación, en este caso está haciendo más trabajo e introduciendo más puntos de falla en su programa.
Mi compañero de clase sugirió que podría estar desperdiciando memoria extra
Está utilizando 26 * sizeof (var *) bytes adicionales de memoria en el segundo ejemplo.
Puedo evitar mezclar. y -> y use el mismo operador -> en todo el código.
Habrá muchas ocasiones en las que se verá obligado a mezclar ambos, y debería acostumbrarse a ambos operadores. Ambos son igualmente importantes, y tener una sólida comprensión de ambos te beneficiará enormemente.
Contraargumento arbitrario: ¿Por qué no utilizar almacenamiento automático y . ¿para todo?
#include <stdio.h> typedef struct var { int **num; int y; int x; int count; } var; struct prog { var variables[26]; }; typedef struct prog prog; int main(void) { prog p = { 0 }; p.variables[0].y = 1; for (size_t i = 0; i < 26; i++) printf("%d\n", p.variables[i].y); } De nuevo, la respuesta es que a veces se puede (aquí, ignorando el miembro de la estructura num y su uso previsto), ya veces no se puede (asignaciones grandes, asignaciones complicadas, asignaciones externas).