¿Cómo libero una matriz completa cuyos elementos se han asignado memoria individualmente a través de llamadas a malloc / calloc [duplicado]?
Por lo que sé, malloc y calloc son solo API de mantenimiento de libros en la memoria subyacente. Teniendo esto en cuenta, me pregunto si una llamada a free () liberará una matriz completa a cuyos elementos individuales se les ha asignado memoria a través de llamadas independientes a malloc (o calloc).
Precisamente, tengo el siguiente código:
int *num,* num_start;
num_start=num;
for(i=0;i<N;i++)
{
num = (int *)calloc(0, sizeof(int));
num++;
}
free(num_start);
¿ free(num_start)
Liberará toda la matriz de N elementos enteros a los que se les ha asignado espacio dinámicamente, de forma independiente?
Respuestas
El "código" que publicó no tiene ningún sentido y es incorrecto.
int *num, num_start;
num_start=num;
num_start es un número entero, no un puntero.
for(i=0;i<N;i++)
{
num = (int *)calloc(0, sizeof(int));
num++;
}
para ser honesto, no entiendo qué se supone que debe hacer este código, pero seguro que está mal
si desea asignar memoria para N
enteros
int *num = calloc(N, sizeof(*num));
y para liberar solo necesitas
free(num);
O si desea asignar un puntero para almacenar N punteros a N enteros
int **allocate(size_t N)
{
int **num = malloc(N * sizeof(*num));
for(size_t i=0; i<N; i++)
{
num[i] = calloc(N, sizeof(**num));
}
return num;
}
void arrayfree(int **num, size_t size)
{
for(size_t i = 0; i < size; i++)
{
free(num[i]);
}
free(num);
}
Cuando asigna memoria, debe verificar si la operación fue exitosa. Esas comprobaciones no se incluyen en el ejemplo para facilitar la lectura del código.
Las funciones calloc()
y malloc()
devuelven un puntero a la asignación que funciona como un identificador para liberar esa memoria. Si bien puede hacer copias de ese puntero y manipularlas como mejor le parezca, cuando llame free()
debe proporcionar el valor original .
Es decir, esto funciona:
// Original allocation
int* x = calloc(42, sizeof(int));
// Making a new (independent) copy of the pointer to a new pointer
int* p = x;
// Arbitrary pointer manipulation and mangling
x++;
// Freeing with the copied value
free(p);
También puede ser un poco aventurero, siempre que regrese a su destino original:
int* x = calloc(42, sizeof(int));
x += 40;
x -= 30;
x += 10;
x -= 13;
x -= 7;
free(x);
Donde aquí x
ha vuelto a su valor original después de un corto viaje. En la práctica general, es mejor conservar el puntero original que tener que reconstruirlo más tarde. Haga copias si tiene la intención de manipularlas.