vector<vector<vector<string>>>vcat;
for (int x=0; x<1000; x++)
{
  vector<vector<string>>twodim;
  vector<string>onedim;
  vcat.push_back(twodim);
  vcat[x].push_back(onedim);
  vcat[x][0].push_back("test");
}

Kann mir einer sagen warum?
Danke!

EDIT:
Memory Leak gibt's bei mir auch nicht. Würde dafür auch keinen Grund geben.

1. Gib uns den Code den du wirklich benutzt
2. Etwas mehr Informationen bitte, wie kommst du drauf das hier ein Memory Leak verursacht wird?

for (int a=0; a<vcat.size()-1; a++)
			{
				for (int b=0; b<vcat[a].size()-1; a++)
				{
					for (int c=0; c<vcat[a][b].size()-1; c++)
					{
						vcat[a][b][c].erase(vcat[a][b][c].begin(),vcat[a][b][c].end());
					}
					vcat[a][b].erase(vcat[a][b].begin(),vcat[a][b].end());
					cout << a;
				}
				vcat[a].erase(vcat[a].begin(),vcat[a].end());
			}
			vcat.erase(vcat.begin(),vcat.end());

auch wenn ich die elemente lösche bleibt der speicherbedarf hoch:

Und was hat der Speicherverbrauch mit einem Speicherloch zu tun? (Fast) nichts. std::vector erzeugt von sich aus keine Speicherlöcher.

std::vector<int> v;
// fülle v
v = std::vector<int> ();

Viele Implementierungen von std::vector geben den Speicher, den sie einmal angefordert haben nicht frei und daher ist das ganz normal. Wenn du einen std::vector wirklich leeren möchtest, dann mach das so:

std::vector<int> v;
// fülle v
v = std::vector<int> ();

Das hilft IIRC auch nicht, sondern leert auch nur v. Der behält seinen Speicher trotzdem bein. Wirklich gelöscht wirds durch swap:

std::vector<int> v;
// fülle v
v.swap(std::vector<int>())

void foo()
{
	vector<vector<vector<string>>>vcat; 
	for (int x=0; x<100000; x++) 
	{ 
		vector<vector<string>>twodim; 
		vcat.push_back(twodim); 
		for (int y=0; y<5; y++)
		{
			vector<string>onedim; 
			vcat[x].push_back(onedim); 
			vcat[x][y].push_back("test"); 
		}
	}
	vcat.clear();
}

Danke janjan docshoe:
http://www.codeproject.com/KB/stl/stl_ml.aspx
überträgt denn der vector nicht einen Zeiger auf den Wert?

Das ist jetzt das dritte Paar Schuhe...
Im dem Fall, wo lediglich Zeiger auf Objekte in einem Vektor verwaltet werden ruft der Vektor beim Löschen lediglich den Destruktor für Zeiger auf, aber nicht den Destruktor für das Objekt, auf das der Zeiger zeigt. In deinem Fall mag das ja Sinn machen, aber es gibt Fälle, wo man das eben nicht möchte.
boost/TR1 bieten da einige Möglichkeiten, um das automatische Freigeben auch für Zeiger in Containern (smart pointer, pointer container).

Das hilft IIRC auch nicht, sondern leert auch nur v. Der behält seinen Speicher trotzdem bein. Wirklich gelöscht wirds durch swap:

std::vector<int> v;
// fülle v
v.swap(std::vector<int>())

Das war mir auch noch nicht bekannt. Gibt vector den allokierten Speicher nicht im Destruktor wieder frei?

std::vector<int> v;
// fülle v
v = std::vector<int> ();

Das wird so nicht kompilieren, da RValues nicht an Non-Const-Referenzen gebunden werden. Richtig wäre

std::vector<int>().swap(v);

Doch, aber in dem Beispiel wird nirgendwo der Destruktor aufgerufen:

Entweder meinen wir verschiedene Beispiele, aber in dem vom Eröffnungspost werden nur statische Objekte verwendet. Der Destruktor wird am Routinenende also aufgerufen.

Entweder meinen wir verschiedene Beispiele, aber in dem vom Eröffnungspost werden nur statische Objekte verwendet. Der Destruktor wird am Routinenende also aufgerufen.

Dann verstehe ich die Frage nicht. Bezieht sie sich auf die swap() Technik?

Ich hatte das jetzt so verstanden, dass vector<> generell seinen Speicher nicht freigeben würde. Ich denke mal, dass ich das hier falsch verstanden habe.

Doch, std::vector gibt sämtlichen allokierten Speicher am Ende seiner Lebenszeit wieder frei. Fallstricke wie Zeiger auf dynamisch erzeugte Objekte, deren Adressen in std::vector verwaltet werden gibt es natürlich, aber solange man "vollständige" Objekte im Vektor ablegt treten keine memory leaks auf.

pumuckl schrieb:

Das hilft IIRC auch nicht, sondern leert auch nur v. Der behält seinen Speicher trotzdem bein. Wirklich gelöscht wirds durch swap:

std::vector<int> v;
// fülle v
v.swap(std::vector<int>())

Das war mir auch noch nicht bekannt. Gibt vector den allokierten Speicher nicht im Destruktor wieder frei?

Doch, und zwar nur im Destruktor. Im gezeigten Code wird aber nur der temporäre leere vector zerstört, der vector v behält seinen Speicher. Der op= von std::vector arbeitet wohlgemerkt nicht mit copy&swap - das liegt an der "don't pay for what you don't use"-Philosophie von C++, die verbietet, für einen exceptionsicheren op= einen temporären vector von potentiell mehreren MB Größe anzulegen.