Liberar toda la memoria

[karmbzk]

Hola a todos, estoy con un programa sencillo en el que creas 100.000 alumnos con nombre y edad y luego los borras todos para liberar toda la memoria posible. Este es el programa:
Main.cpp

Código:

#include <stdio.h>
#include <stdlib.h>
#include "Alumno.h"

int main(){
	system("PAUSE");
	const int objetos = 100000;
	Alumno *alumnos[objetos];
	CString nombre = "Carmelo";
	int i;

	//Creo los 100.000 alumnos
	for (i = 0; i < objetos; i++){
		alumnos[i] = new Alumno();
		alumnos[i]->setNombre(nombre);
		alumnos[i]->setEdad(20);
		printf("La edad de %s es: %d\n", alumnos[i]->getNombre().Get(), alumnos[i]->getEdad());
	}
	system("PAUSE");

	//Borro los 100.000 alumnos y el array que los contenía.
	for (i = 0; i < objetos; i++){
		SAFE_DELETE(alumnos[i]);
	}
	SAFE_DELETE_ARRAY(*alumnos);
	system("PAUSE");
}

Alumno.h

Código:

#include "CString.h"
#define	SAFE_DELETE(memory)	{ delete memory; memory = nullptr; }
#define SAFE_DELETE_ARRAY(memory) if(memory) { delete [] memory; memory = nullptr; }

class Alumno
{
private:
	int edad;
	CString nombre;

public:
	void setNombre(CString nombre){ this->nombre = nombre; };
	CString getNombre(){ return nombre; };

	void setEdad(int edad){ this->edad = edad; };
	int getEdad(){ return edad; };
};

Con el administrador de tareas de Windows puedo comprobar la memoria usada en cada momento, y esto es lo que sucede:

Al iniciar el programa usa 1160KB de memoria.
Al crear los 100.000 alumnos usa 5240KB de memoria.
Al borrar todos los alumnos usa 1576KB de memoria.

Se supone (o al menos creo yo) que al liberar toda la memoria de los alumnos el programa debería usar la misma memoria que al iniciar el programa, pero al parecer usa más memoria al final que al principio: 1160KB al principio < 1576KB al final.
¿Esto es normal? ¿O hay alguna forma de liberar esa memoria restante?

Gracias!!

[CalgaryCorpus]

No entiendo el SAFE_DELETE_ARRAY.

Entiendo que el arreglo fue definido estaticamente. Tienes 100000 punteros y no los puedes liberar pues no se pidio memoria dinamica para ellos.

¿Como cambia el programa sin la invocacion de esta macro?
o que se quería decir al invocarla?

Por otro lado, aqui se menciona que en Windows, la liberacion de memoria es una marca de liberado y hay reciclaje de lo marcado como libre.

http://stackoverflow.com/questions/1...memory-windows

[karmbzk]

Hola CalgaryCorpus,

SAFE_DELETE_ARRAY es una macro que borra un array como la macro SAFE_DELETE. Las dos macros están definidas en Alumno.h y las copié de una programa por internet que funcionaba...

Usar las macros es lo mismo que usar delete, está comprobado, pero si se han borrado los objetos correctamente, es normal que se usen 416KB más de memoria que al principio?

Si esa memoria está marcada como libre, significa que si creo otros objetos usarán esa memoria, y que por lo tanto no es basura la memoria que "sobra" respecto al principio no?

Gracias!!

[CalgaryCorpus]

La macro esta bien definida. En mi opinin, usarla en esta ocasion está mal, pues el arreglo es estatico, dicho de otra forma, no fue creado usando new. Solo su contenido lo fue y ahi es correcto usar la otra macro.

Segun el link en modo debug la memoria es administrada para marcar y reusar, lo que podria explicar la diferencia. Podria comprobarse pidiendo mas memoria despues de la liberacion. Si ella no crece inmediatamente, es cierto. Si crece con peticiones pequeñas existe un memory leak por descubrir

[Aemilius]

Aún si el programa está correctamente hecho y libera toda la memoria que reservó tienes que tener en cuenta que existe un "costo administrativo" por utilizar new/delete o malloc/free.

Existe todo un sistema bastante complejo que permite reservar y liberar memoria dinámicamente y que está enmascarado por esas funciones, además de tener que lidiar con otros problemas como sincronización de hilos y reducir fragmentación interna y externa.

Generalmente el manejador de memoria no pide al sistema operativo un bloque de memoria cada vez que llamas a malloc o a new, generalmente reserva un bloque grande y luego reparte de ese bloque cada vez que llamas a malloc o a new. Tienes que tener en cuenta que el sistema operativo tiene que atender distintos procesos al mismo tiempo por lo que no es buena idea molestarlo a menudo. Probablemente no toda la memoria es devuelta al sistema operativo porque es más probable que el programa vuelva a utilizar esa memoria a que la deje de utilizar totalmente.