Podría alguien decirme la diferencia entre:¿Cuál es la diferencia entre liberar el puntero y asignarlo a NULL?
int *p;
p=(int*)malloc(10*sizeof(int));
free(p);
o
int *p;
p=(int*)malloc(10*sizeof(int));
p=NULL;
free se desasignar la memoria que p puntos a - simplemente asignándole a NULL no (y por lo tanto tendrá un recuerdo fuga).
Vale la pena mencionar que es una buena práctica para asignar el puntero a NULL después de la llamada a free, ya que esto evitará que accidentalmente intentar acceder a la memoria liberada (que todavía es posible, pero absolutamente no se debe hacer)
en C, un puntero es, literalmente, solo un valor, como un int. cuando lo establece en un valor con '=', literalmente, todo lo que sucede es que se establece como ese valor, no hay nada más que ocurra detrás de las escenas. – matt
No hay recolección de basura en C, por lo que si no libera explícitamente una porción de memoria, nunca se liberará, incluso si no hay referencias a ella. Tal vez provenga de un fondo en lenguajes recolectados, por lo que puede ser difícil cambiar su forma de pensar, pero siempre es importante recordar liberar "manualmente" todos los recursos en lenguajes de bajo nivel como C.
Espero que esto ayuda a Saludos
A menos que instale un recolector de basura, por supuesto; v) – Potatoswatter
p es puntero (a un bloque asignado dinámicamente en la memoria [ "en el montón"])
Esto significa que p es una variable que contiene la direcciónen memoria de un bloque particular (o algún tamaño particular, en el ejemplo un bloque lo suficientemente grande como para contener 10 enteros).
free(p); indica a la lógica de gestión de la memoria (del C Runtime) que la memoria ocupada previamente por el bloque que p señala puede reutilizarse.
p = NULL; establece el valor de p en NULL (la dirección que contenía anteriormente se pierde) pero el bloque en la memoria que apunta también se considera en uso.
Puede haber cierta confusión porque en lenguajes como Java, C#, Python, etc. simplemente asignando la variable a NULL (o a otra dirección para el caso), liberará automáticamente la memoria subyacente (suponiendo que no haya otras referencias a esto dirección existe en otras variables en vivo).
Este no es el caso en C o C++, lo que conduce a errores como el siguiente:
free(p);
// possibly some some code etc.
// later:
p[6] = 'a'; // <<--- Ouch we're modifying whatever new variable is there !!!
o
// didn't call free(p)
p = NULL;
// now the memory allocated for p is held in memory even though it
// is not going to be used (assuming no copies of p or of pointers to part
// of that block were made.
Este último caso es sólo un desperdicio de recursos, el primero puede dar lugar a difíciles de encontrar errores.
Por eso un lenguaje típico C es:
free(p);
p = NULL;
no llamar libre y asignar directamente a NULL dará lugar a una pérdida de memoria como se explica por otros. Puede consultar este link para obtener detalles claros sobre fugas de memoria y otros problemas relacionados con la memoria.
Al liberar la memoria asignada, se destraba y permite que la memoria se use en otro lugar mientras se conserva el puntero al lugar donde se asignó la memoria.
Establecer un puntero a la memoria asignada a NULL no lo desasigna.
Si está utilizando una implementación que utiliza un malloc basado en montón, depure algo que asigna, usa y libera memoria, y haga lo mismo con algo que asigna, utiliza y establece el puntero a la memoria en NULL.
La gestión de memoria depende de la implementación (ver http://en.wikipedia.org/wiki/Malloc#Implementations).
La mejor manera es primero liberar la memoria y luego ponerlo a NULL:
free(p);
p = NULL;
1.
int *p; p= (int *) malloc(10*sizeof(int)); free(p);
la memoria se libera de nuevo al montón. pero el puntero aún apunta a la ubicación de la memoria liberada. Por lo tanto, si se sigue utilizando, conduciría a una corrupción de memoria.
por lo tanto, lo correcto es restablecer el puntero a NULL explícitamente para evitar el uso de ese puntero.
no es aconsejable escribir del puntero de retorno en C
2.
int *p; p=(int *)malloc(10*sizeof(int)); p=NULL;
Esto resultaría en una memoria fugas: como la memoria asignada no se libera aquí . Usted acaba de restablecer el puntero a NULL.
p=NULL no desasigna la memoria. Si ya no necesita utilizar la memoria apuntada por p, debe usar free(), de lo contrario, habrá pérdida de memoria. También debe configurar p=NULL después de llamar al free() para evitar el acceso erróneo a esa memoria nuevamente en el futuro.
C no es Java. :) – vladr