ich stehe momentan etwas auf dem Schlauch.
Wenn ich mit new neue Objekte erzeuge und diese mit delete wieder lösche wird doch der dabei verwendete Speicher wieder freigegeben....oder hab ich das falsch verstanden?

Wenn ich das folgende Programm laufen lasse (unter: Ubuntu 9.04 mit gcc 4.3.3)
wird nach der 2. For-Schleife der Speicher nicht wieder frei gegeben. Das Programm beansprucht nach dem Aufruf von delete genauso viel Speicher wie nach der Allocation mit new.

#include <iostream>
#include <string>
#include <vector>

#define SIZE 20000000

class tClass
{
public:
	tClass(long c)
	: d(c)
	{};

private:
	long d ;
};

int main()
 {

	std::vector<tClass*> test (SIZE);
	std::string input;

	for(unsigned int i = 0; i < test.size(); i++)
	{
		test[i]= new tClass(i);
	}

	std::cout << "Memory Allocation ready!" << std::endl;
	std::cin >> input;

	for(unsigned int i = 0; i < test.size(); i++)
	{
		delete test[i];
	}

	test.clear();
	std::cout << "Memory DeAllocation ready!" << std::endl;
	std::cin >> input;

  return 0;
 }

Hab ich da nur was falsch verstanden....oder sollte da nicht eigentlich der Speicher wieder ans System zurück gegeben werden, genau wie wenn ich unter C mit malloc Speicher anfordere und mit free wieder frei gebe?

Kann da jemand Licht ins Dunkle bringen?

Danke für eure Hilfe,
StarTraveler

Hallo zusammen,

ich stehe momentan etwas auf dem Schlauch.
Wenn ich mit new neue Objekte erzeuge und diese mit delete wieder lösche wird doch der dabei verwendete Speicher wieder freigegeben....oder hab ich das falsch verstanden?

Wenn ich das folgende Programm laufen lasse (unter: Ubuntu 9.04 mit gcc 4.3.3)
wird nach der 2. For-Schleife der Speicher nicht wieder frei gegeben. Das Programm beansprucht nach dem Aufruf von delete genauso viel Speicher wie nach der Allocation mit new.

#include <iostream>
#include <string>
#include <vector>

#define SIZE 20000000

class tClass
{
public:
	tClass(long c)
	: d(c)
	{};

private:
	long d ;
};

int main()
 {

	std::vector<tClass*> test (SIZE);
	std::string input;

	for(unsigned int i = 0; i < test.size(); i++)
	{
		test[i]= new tClass(i);
	}

	std::cout << "Memory Allocation ready!" << std::endl;
	std::cin >> input;

	for(unsigned int i = 0; i < test.size(); i++)
	{
		delete test[i];
	}

	test.clear();
	std::cout << "Memory DeAllocation ready!" << std::endl;
	std::cin >> input;

  return 0;
 }

Hab ich da nur was falsch verstanden....oder sollte da nicht eigentlich der Speicher wieder ans System zurück gegeben werden, genau wie wenn ich unter C mit malloc Speicher anfordere und mit free wieder frei gebe?

Kann da jemand Licht ins Dunkle bringen?

Danke für eure Hilfe,
StarTraveler

Der Code scheint mir soweit korrekt. Es kann sein, das es nur so aussieht, als würde so viel Speicher verbraucht werden. Eventuell liegt es an der Linux-Archtiketur, die Speicher anders handhabt.

*würg*

StarTraveler schrieb:

Hab ich da nur was falsch verstanden....oder sollte da nicht eigentlich der Speicher wieder ans System zurück gegeben werden, genau wie wenn ich unter C mit malloc Speicher anfordere und mit free wieder frei gebe?

Nicht unmittelbar. Vielleicht brauchst du dreizehn Millisekunden später gerade wieder Speicher, von daher wäre das Zurückgeben etwas unnötig. Du darfst aber davon ausgehen, dass dein Speicher richtig freigegeben wird und in kritischen Fällen (wenn andere Programme dringend Speicher benötigen) auch zur Verfügung steht. Aber grundsätzlich solltest du über TaskManager & Co. nicht zuviel auf das Speicherverhalten deines Programms schliessen.

#define SIZE 20000000

Stroustrup - Makros sind hässlich, dafür gibt´s const.

Makros sind hässlich

Nein.

Mentras schrieb:

dafür gibt´s const.

Nein.

Bitte etwas genauer und weniger pauschalisierend formulieren.
Makros haben viele Einsatzzwecke, allein schon als Header-Guards und Schalter für bedingte Kompilierung. Für Konstanten sind sie aber tatsächlich relativ ungeeignet, ebenso als Funktionsersatz. Richtig cool werden Makros in Präprozessormetaprogrammierung, aber auch sonst sind sie ab und zu recht praktisch.

jaja, ich weiss ist nicht schön, sollte auch nur ein Demo sein.

Erstmal danke für eure Antworten. Was mich allerdings irritiert, ist die Tatsache, dass ich unter der selben Umgebung sofort bemerke, wenn ich einen mit malloc allokierten Speicher mit free freigebe. Ich sehe das sofort z.B. mit htop. Im obigen Beispiel ist das aber eben nicht der Fall, deshalb bin ich so verwirrt.

jaja, ich weiss ist nicht schön, sollte auch nur ein Demo sein.

Jaja, ist klar. :p
(Wenn du's schon weisst, schreibe doch const int hin, das ist sogar kürzer zu schreiben und erspart nervige Antworten ;))

StarTraveler schrieb:

Was mich allerdings irritiert, ist die Tatsache, dass ich unter der selben Umgebung sofort bemerke, wenn ich einen mit malloc allokierten Speicher mit free freigebe. Ich sehe das sofort z.B. mit htop. Im obigen Beispiel ist das aber eben nicht der Fall, deshalb bin ich so verwirrt.

operator new/delete und malloc()/free() müssen nicht gleich implementiert sein, sind es normalerweise auch nicht. Soviel ich weiss, ist malloc() eher für grössere Speicherbereiche optimiert, während operator new schnell kleine Blöcke anfordern kann.