C-estructuras liberadoras

Debido a que definió el struct como consistiendo en char arrays, las dos cadenas son la estructura y liberar el struct es suficiente, ni hay una manera de liberar el struct pero mantener los arrays. Para ese caso, querrías hacer algo como struct { char *firstName, *lastName; }, pero luego necesitas asignar memoria para los nombres por separado y manejar la pregunta de cuándo liberar esa memoria.

Aparte: ¿Hay una razón que desea mantener los nombres después de que el struct ha sido liberado?

Primero debe saber cuánta memoria se asigna cuando define y asigna memoria en el caso siguiente.

   typedef struct person{
       char firstName[100], surName[51]
  } PERSON;
  PERSON *testPerson = (PERSON*) malloc(sizeof(PERSON));

1) El sizeof (PERSON) ahora devuelve 151 bytes (No incluye relleno)

2) La memoria de 151 bytes se asigna en heap.

3) Para free, llame a free (testPerson).

Pero si declaras tu estructura como

  typedef struct person{
      char *firstName, *surName;
  } PERSON;
  PERSON *testPerson = (PERSON*) malloc(sizeof(PERSON));

Entonces

1) El sizeof (PERSON) ahora devuelve 8 bytes (No incluye relleno)

2) Necesidad de asignar memoria para nombre y apellido llamando a malloc() o calloc(). como

        testPerson->firstName = (char *)malloc(100);

3) Para liberar, primero libera a los miembros en la estructura que libera la estructura. i. e, gratis (testPerson- > Nombre); gratis (testPerson- > Apellido); libre (testPerson);

De esta manera solo necesita liberar la estructura porque los campos son arrays con tamaños estáticos que se asignarán como parte de la estructura. Esta es también la razón por la que las direcciones que ves coinciden: la matriz es lo primero en esa estructura. Si declaras los campos como char * tendrás que manualmente malloc y liberarlos también.

Mallocs y frees necesitan ser emparejados.

Malloc agarró un pedazo de memoria lo suficientemente grande para una Persona.

Cuando usted libera le dice a malloc que el pedazo de memoria que comienza "aquí" ya no es necesario, sabe cuánto asignó y lo libera.

Si llama

 free(testPerson) 

O

 free(testPerson->firstName)

Todo lo que free() recibe en realidad es una dirección, la misma dirección, no puede decir a cuál llamaste. Sin embargo, su código es mucho más claro si usa free(testPerson), claramente coincide con Malloc.

No puedes liberar tipos que no están asignados dinámicamente. Aunque los arrays son sintácticamente similares (int* x = malloc(sizeof(int) * 4) se puede usar de la misma manera que int x[4]), llamar a free(firstName) probablemente causaría un error para este último.

Por ejemplo, tome este código:

int x;
free(&x);

free() es una función que toma un puntero. &x es un puntero. Este código puede compilarse, aunque simplemente no funcione.

Si pretendemos que toda la memoria se asigna de la misma manera, x se "asigna" en el definición, " freed "en la segunda línea, y luego" freed " de nuevo después del final del ámbito. No puedes liberar el mismo recurso dos veces; te dará un error.

Esto ni siquiera menciona el hecho de que por ciertas razones, es posible que no pueda liberar la memoria en x sin cerrar el programa.

Tl; dr: Solo libera el struct y estarás bien. No llame a free en arrays; solo llámelo en memoria dinámicamente asignada.

free no es suficiente, free solo marca la memoria como no utilizada, los datos de la estructura estarán allí hasta que se sobrescriban. Por seguridad, establezca el puntero en NULL después de free.

Ex:

if (testPerson) {
    free(testPerson);
    testPerson = NULL;
}

struct es similar a una matriz, es un bloque de memoria. Puede acceder al miembro de struct a través de su desplazamiento. El miembro de la primera estructura se coloca en offset 0 por lo que la dirección del miembro de la primera estructura es la misma que la dirección de la estructura.